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.

Coba Bikin Buku Lagi .. “Data Mining dengan Matlab & Python”

Buku berbeda dengan artikel jurnal dari sisi konten. Jika jurnal merupakan hasil penelitian terkini, buku sedikit tertinggal beberapa tahun. Namun biasanya buku lebih stabil keilmuwannya, alias sudah “established”. Biasanya buku digunakan sebagai sumber referensi untuk kasus tertentu karena formatnya yang rapi, tidak terlepas ke sana-sini seperti artikel ilmiah. Toh, jurnal pun sesungguhnya terbit setelah penelitian yang dilakukan beberapa tahun belakangan, jadi tidak baru-baru amat. Postingan ini sedikit memberi gambaran bagaimana membuat buku dengan mudah dan cepat.

Materi Kuliah

Waktu itu diminta ngajar mata kuliah “Data Mining” di kampus besar yang terletak di Pondok Kopi. Total ada 14 pertemuan. Kebetulan perkuliahan disertai dengan praktek di laboratorium. Dalam satu kali pertemuan saya buat satu bab, jadi total setelah perkuliahan selesai, jadilah buku sekitar 14 bab. Jadi ketika mengajari, langsung saja “capture” langkah-langkahnya. Tidak perlu ditulis dulu karena menulis membutuhkan waktu. Toh, dari hasil capture kita tahu apa yang harus ditulis nanti. Lihat postingan saya 7 tahun yang lalu tentang teknik ini.

Di akhir semester ada waktu kira-kira sebulan untuk membuat kata-kata yang mengalir. Ada sisi positifnya jika kita menulis materi kuliah. Ketika mempraktekan terkadang dapat diketahui apakah modul berjalan dengan baik. Terkadang ada saja hal-hal yang dijumpai siswa yang membuat praktik tidak berjalan. Hal ini penting untuk ditulis karena pembaca buku adalah pembelajar mandiri yang harus jelas dari “a” sampai “z” tanpa ada guru/tutor. Jika tidak berjalan, tentu saja mengecewakan pembaca. Namun toh, biasanya ada saja masalah dijumpai dan pembaca mengirim pertanyaan lewat email, terutama masalah kompatibilitas dengan laptopnya. Tapi biasanya berjalan dengan baik oleh pembaca. Kalaupun hanya memanfaatkan dari “help” tetap harus dicoba oleh penulis apakah bisa berjalan dengan baik atau perlu alat bantu lain. Beberapa penulis buku tidak menganjurkan memanfaatkan “help” karena untuk apa buat buku kalau di “help”-nya sudah ada.

Hasil Penelitian

Nah, yang ini agak sulit. Beberapa penerbit menolak membukukan hasil penelitian (skripsi, tesis, atau disertasi). Hal ini saya dengar langsung oleh perwakilan penerbit (waktu itu dari Andi offset) yang diundang oleh pihak kampus saya waktu itu (STMIK Nusa Mandiri). Saya lupa tahunnya, yang jelas waktu itu masih “ST”. Oiya, mungkin dosen-dosen muda sekarang heran melihat S1 yang menjadi dosen. Pasti lebih heran lagi kalau tahu jabatan fungsional Lektor saya diperoleh waktu masih bergelar S1 (lektor 200). Waktu itu memang jamannya orang enggan jadi dosen, sehingga kebutuhan dosen masih tinggi. Nah, si penerbit bersedia membukukan hasil penelitian jika mampu mengemas laporan penelitiannya dalam bentuk sudut pandang “orang awam”. Maksudnya pembaca harus dijejali hal-hal yang perlu agar mereka bisa mengikuti. Ini yang membuat penulis harus kerja ekstra mengetik ulang hasil penelitiannya. Nah nanti di akreditasi terbaru dengan format 9 standar, tiap dosen harus memasukan hasil penelitiannya ke materi ajar. Jadi buku yang dibuat kombinasi dari materi kuliah dengan hasil penelitian. Agak repot juga ketika mengajar mata kuliah yang berbeda dengan roadmap penelitiannya, jadi tidak bisa disisipi hasil penelitian. Jadi intinya, penerbit ingin pembaca tidak membutuhkan sumber-sumber lain untuk memahami, artinya dengan satu buku itu sudah paham. Kalau memerlukan buku lainnya, biasanya pembaca kerepotan karena harus merogoh kocek lagi untuk beli buku lainnya.

Menolong Orang Lain

Siapa yang ditolong? Banyak, misalnya kampus (lewat poin akreditasi karena ada buku), dosen (karena ada materi kuliah), industri/developer (untuk membuat software/aplikasi), dan mahasiswa (untuk kuliah dan tugas akhir/skripsi). Hal ini terjadi karena buku berbeda dengan artikel ilmiah yang terkadang merahasiakan kode sumber, sementara buku selain menyertakan kode sumber, terkadang diberikan CD/DVD atau file yang dishare di internet (dari website, Github, dan lain-lain). Kebanyakan mereka seumur hidup hanya sekali merasakan skripsi/tugas akhir, jadi tidak mungkin melupakan buku yang ia baca ketika berpusing-pusing ria dalam merampungkan kuliahnya. Saya pun sampai sekarang masih ingat buku-buku yang membantu saya lulus kuliah. Terakhir, tentu saja membantu penerbit. Mereka secara jujur kesulitan mencari penulis buku, padahal jumlah penulis potensial di tanah air harusnya di atas negara lain.

Revisi Atau Baru?

Sebenarnya saya ingin merevisi buku yang dulu, tetap mengingat isi yang jauh berbeda, terpaksa membuat versi yang benar-benar baru. Salah satu hal yang membedakan adalah “web-based machine learning“. Silahkan cari di internet buku tentang machine learning atau data mining berbasis web, masih jarang. Hal ini terjadi karena antara front-end (web developer) dengan back-end (data scientis) berasal dari orang dengan fokus yang berbeda. Perlu ada jembatan yang menghubungkan keduanya. Pengguna pun lebih nyaman menggunakan apikasi data mining dengan GUI berbasis web yang mudah diakses dari manapun. Jadi dengan tambahan web-based machine learning mudah-mudahan dapat menjembatani front-end dan back-end. Penggunaan bahasa Python pun karena trend bahasa pemrograman ini yang terus naik (lihat pos yang lalu) sampai-sampai Google mengadopsi bahasa ini dalam pemrograman onlinenya (lihat pos yg lalu tentang Google Colab).

Sebagai bonus, penulis terkadang harus cuek, apalagi menulis buku. Jika novel atau cerpen, kita bisa menggunakan nama samaran jika kita tidak ingin repot dengan para kritikus. Beberapa pakar di tanah air terkadang merendahkan tulisan dari penulis-penulis lokal dan cenderung menganjurkan buku-buku internasional yang “wah”. Tidak apa-apa kalau punya pandangan seperti itu, toh niat kami membantu anak-anak yang mungkin kurang skill bahasa Inggrisnya dengan bahasa yang mudah mereka mengerti. Jika dikatakan tulisan “instan” ya tidak apa-apa, kan repot juga mahasiswa dipaksa belajar bahasa Inggris dulu baru bisa lulus. Prinsip saya dan penulis-penulis lokal lainnya sebenarnya sederhana, membantu memberikan pemahaman kepada masyarakat umum, tidak merahasiakan ilmu atau menyarankan mereka mengikuti kursus yang harganya terkadang tidak terjangkau oleh mahasiswa-mahasiswa rata-rata di tanah air yang untuk bayar kuliah saja sulit. Tentu saja kalau mampu silahkan buat buku bertaraf internasional yang “wah” dan itu bagus banget menurut saya. Semoga berminat menulis buku.

Update: 10 April 2021

Buku sudah avaiable di toko-toko buku dan online shop, semoga bermanfaat.

buku DM new

Update: 1 Januari 2025

Tidak terasa sudah 4 tahun vakum menulis. Coba buat buku lagi mengingat teknologi saat ini berkembang sangat cepat. Masih dengan tema yang sama, tapi dengan implementasi khusus yang sangat dibutuhkan oleh mahasiswa, terutama level S1 dan S2.

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)

Memanggil Fungsi Eksternal Pada Python

[Hari|Matkul|Jur|Dosen: Rabu.13.05.2020|Logika-prt.9|AK|Rahmadya,PhD]

Sebelumnya telah dibahas bagaimana menggunakan fungsi pada bahasa pemrograman Python (lihat pos yang lalu). Terkadang fungsi-fungsi tertentu digunakan oleh program-program Python lain sehingga perlu dibuat satu file terpisah agar tidak perlu menulis kode fungsi di tiap-tiap program. Misalnya kode pembelian barang berikut berisi kode yang ada di dalamnya fungsi yang dibutuhkan, didefinisikan dengan keyword “def”.

print(" ———Toko Amanah Jaya———")
def total(harga,jumlah):
	"""fungsi untuk menghitung Total bayar"""
	return harga*jumlah
def diskon(harga):
	""" fungsi menghitung diskon """
	if (harga &gt;= 500000):
		potongan=harga*0.1
	else:
		potongan=harga*0.05
	return potongan
def bayar(harga,potongan):
	""" fungsi menghitung total bayar """
	return harga-potongan

#input data
harga= int(input("masukan harga barang: "))
jumlah= int(input("masukan jumlah baju yang dibeli: "))
Total=total(harga,jumlah)
potongan=diskon(Total)
tagihan=bayar(Total,potongan)
print("Total Harga = ", "Rp.",Total)
print("Diskon", "Rp.", potongan)
Bayar=int(input("Jumlah Nominal Uang =" ))
Kembalian= (Bayar-tagihan)
print("Uang Kembalian = ", "Rp.",Kembalian)

Bagaimana cara memindahkan fungsi tersebut ke file lain? Caranya mudah saja. Pertama cek dulu apakah program sudah berjalan sesuai dengan spesifikasinya. Jika sudah tidak ada masalah, tinggal “cut” saja dan buat file baru, di sini saya beri nama “diskon.py” dan letakan di folder yang sama. Jika dengan Google Colab, upload saja file tersebut di menu “upload file”. Untuk memanggil file tersebut gunakan instruksi “from” dan “import” di program utama berikut ini.

from diskon import total,diskon,bayar
print(" ———Toko Amanah Jaya———")
#input data
harga= int(input("masukan harga barang: "))
jumlah= int(input("masukan jumlah baju yang dibeli: "))
Total=total(harga,jumlah)
potongan=diskon(Total)
tagihan=bayar(Total,potongan)
print("Total Harga = ", "Rp.",Total)
print("Diskon", "Rp.", potongan)
Bayar=int(input("Jumlah Nominal Uang =" ))
Kembalian= (Bayar-tagihan)
print("Uang Kembalian = ", "Rp.",Kembalian)

Jalankan program dan pastikan berjalan seperti sebelumnya (tanpa file eksternal). Perhatikan juga penggunaan “if-else” pada python di file “diskon.py” tersebut.

Untuk jelasnya silahkan buka link youtube saya berikut ini.

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.

Membuat Aplikasi Web-based Machine Learning dengan Flask dan Jinja2

Sebenarnya Machine Learning (ML) bekerja di backend. Tetapi tidak ada salahnya bagi data saintis mencoba aplikasi front-end nya, misalnya menggunakan Flask dan Jinja2 untuk bahasa Python (lihat pos tentang Flask dan Jinja2). Untuk Jupyter Notebook sebenarnya sudah disiapkan library Tkinter, tetapi berbasis desktop (lihat pos yang lalu tentang Tkinter).

Cukup baik hanya saja perlu menjalankan Jupyter Notebook dan tampilan GUI berbasis desktop. Jika kita bisa menggunakan aplikasi tersebut berbasis web, maka pengguna tidak perlu memiliki Python dengan library-library yang dibutuhkan.

Persiapan

Flask memberikan fasilitas pemrograman web-based ML di sisi server. Oleh karena itu pustaka perlu disiapkan terlebih dahulu. Seperti disinggung pos yang lalu, diperlukan satu file python dan template. Di sisi python perlu diimpor library yang diperlukan. Pastikan tidak ada error di sisi impor seperti tampilan di bawah ini dimana library pandas belum ada di environment.

Tes Running ML

Terkadang kita sudah membuat aplikasi ML di backend dan akan dibuatkan aplikasi front-end nya di web. Langkah pertama adalah mencoba menjalankan ML tersebut langsung saja di web tanpa input-output (GUI) di web. Hal ini memastikan mesin berjalan sebelum dibuatkan GUI-nya mengingat fase ini adalah krusial. Repot juga kan ketika GUI dibuat tapi ML tidak berfungsi. Istilahnya ML kita jadikan seperti “Hello World”.

Masukan saja tiap sel satu-satu dari ML yang sudah ok di Jupyter Notebook. Dan pastikan di indikator web tidak ada error. Tiap kali source kita save ternyata langsung dieksekusi realtime. Di sini ada dua data csv, untuk training dan untuk testing, yang nanti dalam implementasinya berupa GUI input.

Tampak instruksi “print(y_train)” pada baris 21 muncul di indikator server web. Hal ini terjadi karena di baris 27 “debug=True” sehingga ketika perubahan kode di “svm.py” langsung dieksekusi. Di sini hasil proses dari instruksi “print” belum dimunculkan di web.

Berikutnya jika ML sudah berjalan via web, tinggal membuat GUI input data yang akan diprediksi. Sekian semoga bisa jadi inspirasi.

NOTE: Untuk lebih jelas, silahkan lihat video Youtube berikut iniyang membahas kasus di atas.

Program Sederhana Python dengan Fungsi

[Hari|Matkul|Jur|Dosen: Rabu.29.04.2020|Logika-prt.7|AK|Rahmadya,PhD]

Jika pada pertemuan yang lalu program menggunakan input, proses dan output seperti biasa, pada pertemuan kali ini menggunakan sebuah fungsi. Setelah data diterima, fungsi dipanggil untuk memproses data tersebut. Hasilnya ditampilkan lewat perintah print.

print(" ———Toko Amanah Jaya———")
def total(harga,jumlah):
"""fungsi untuk menghitung Total bayar"""
return harga*jumlah
#input data
harga= int(input("masukan harga barang: "))
jumlah= int(input("masukan jumlah baju yang dibeli: "))
Total=total(harga,jumlah)
#diskon 5% tiap pembelian di atas Rp.100rb
if Total>100000:
Total=Total-0.05*Total
print("Total Harga = ", "Rp.",Total)
Bayar=int(input("Jumlah Nominal Uang =" ))
Kembalian= (Bayar-Total)
print("Uang Kembalian = ", "Rp.",Kembalian)

Baris kedua sampai keempat menunjukan fungsi perhitungan total yang harus dibayarkan. Kata kunci yang menyatakan sebuah fungsi adalah def dilanjutkan dengan tab segai indikator bahwa statemen tersebut adalah fungsi. Pada baris ke-10 dan ke-11 diperkenalkan cara menggunakan if untuk pengecekan kondisi tertentu, misalnya apa perlu diberi diskon atau tidak.

Untuk jelasnya dapat dilihat pada link berikut ini. Lihat postingan berikutnya tentang memanggil fungsi eksternal (file lain). Sekian, semoga bermanfaat.

Menggunakan Graphics Processing Unit (GPU) Google Colab

Google Colab selain menyediakan Integrated Development Environment (IDE) yang diserta kompiler Python juga menyediakan CPU dan GPU-nya. Untuk membuktikannya Google Colab memberikan link tersendiri di sini.

Jika langsung dijalankan sel pertama akan muncul pesan kesalahan sebagai berikut.

Hal ini terjadi karena kita belum mengeset accelerator GPU. Pilih accelerator dengan masuk ke menu Edit Notebook Setting.

Berikutnya Anda diminta memilih acceleratornya. Ada dua pilihan: 1) Graphics Processing Unit (GPU) dan 2) Tensor Processing Unit (TPU). Pilih saja sesuai pokok bahasan kita yaitu GPU.

JIka dijalankan sel pertama program contoh pengaksesan GPU akan muncul keluaran sebagai berikut yang memastikan bahwa GPU ditemukan.

Jalankan sel berikutnya yang menguji kecepatan tensorflow menggunakan CPU dan GPU. Pastikan tidak ada error.

Perhatikan kecepatan eksekusi menggunakan GPU yang lebih cepat kira-kira 20 kali lebih dari CPU. Sekian semoga membuat tertarik memanfaatkan hardware GPU Google.

Django, Flask dan Jinja2 Untuk Python di Web

Biasanya programer Python menggunakan fasilitas Graphic User Interface (GUI) dari library Tkinter (lihat post yang lalu). Namun tren aplikasi berbasis web membuat programer Python membuat aplikasi berbasis web. Postingan ini menggambarkan bagaimana program Python bekerja di web. Pertama-tama yang dibutuhkan adalah donwload library. Di sini saya menggunakan cara tergampang, yaitu dari Anaconda Navigator

Untuk pembuatan aplikasi web skala besar, gunakan Django dengan fasilitas framework-nya yang lengkap. Caranya sama untuk mengunduh librarynya lewat Anaconda Navigator. Pastikan library tersebut terinstal di Anaconda agar nanti bisa digunakan di Jupyter Notebook lewat instruksi import.

Django Atau Flask? Jinja2 untuk Apa?

Sesuai dengan fungsinya, jika ingin membuat aplikasi besar gunakan saja Django. Tetapi untuk aplikasi ringan, flask lebih cepat. Bagaimana dengan Jinja2? Fungsi Jinja2 memang berbeda dengan Django dan Flask. Aplikasi ini berfungsi untuk membuat template yang nanti muncul di browser. Jika sudah ok, template tersebut dapat diterapkan baik di Django maupun Flask. Walaupun Django bisa juga untuk merancang template tetapi dengan Jinja2 programmer lebih senang karena cepat karena tidak membutuhkan fasilitas-fasilitas lain Django yang tidak ada hubungannya dengan template.

Mencoba Flask

Untuk membuat Python web dengan Flask kita harus memiliki template HTML. Gunakan template berikut ini.

Beri nama template.html, silahkan gunakan editor, misalnya notepad. Jangan lupa ekstensi harus html bukan txt. Buat folder baru di direktori Python, beri nama template. Posisi file kira-kira seperti ini. Dimana folder templates harus disediakan, berisi file HTML (lihat refernsi ini). Silahkan isi requirement.txt atau dengan nama lain misalnya readme.txt. Atau tidak ada juga tidak apa-apa karena hanya berisi penjelasan program.

Letakan template.html di folder tersebut. Sementara itu program utama tetap di direktori Python. Gunakan kode berikut.

  • from flask import Flask, render_template
  • app = Flask(__name__)
  • @app.route(“/”)
  • def template_test():
  • return render_template(‘template.html’, my_string=”Wheeeee!”, my_list=[0,1,2,3,4,5])
  • if __name__ == ‘__main__’:
  • app.run(debug=True)

Masuk ke Terminal dan jalankan dengan mengetik.

  • python run.py

Anda harus berhasil melihat hasilnya di http://127.0.0.1:5000 seperti instruksi di terminal. Di sini maksudnya kita diminta melihat localhost dengan port 5000, port yang diberikan oleh flask untuk mengakses via browser.

Silahkan lihat referensi di bawah untuk melihat bagaimana Jinja2 bekerja pada template. Di atas digunakan Flask, bisa juga dengan Django. Python saat ini sangat kuat dalam komputasi yang bekerja di back-end misalnya untuk mesin pembelajaran, dengan aplikasinya bisa jalan juga di web, berarti bahasa ini sangat diminati karena bisa bekerja selain di back-end maupun front-end, mengungguli bahasa-bahasa komputasi lainnya (lihat post yang lalu tentang tren bahasa pemrograman).

Referensi: https://realpython.com/primer-on-jinja-templating/

 

Program Sederhana Python dengan Google Interactive Notebook (Google Colab)

[Hari|Matkul|Jur|Dosen: Rabu.22.04.2020|Logika-Prt.6|AK|Rahmadya,PhD]

Bahasa Python kian digemari karena sederhana dan cepat. Beberapa perusahaan besar sudah menerapkan bahasa ini, salah satunya adalah Google yang memberikan fasilitas bahasa pemrograman Python online lewat Google Interactive Notebook (http://colab.research.google.com). Selain menyediakan fasilitas bahasa tersebut, Google Colab juga menyediakan tiga jenis prosesor handalnya untuk keperluan mesin pembelajaran (machine learning) yaitu: Central Processing Unit (CPU), Graphic Processing Unit (GPU) dan Tensor Processing Unit (TPU). Berikut cara mencobanya.

Pertama-tama masuk ke situs Google Colab yang sudah disebutkan di atas. Jangan lupa kita harus punya login Gmail (gmail. Com atau ac.id yang berbasis Gmail). Berikutnya cancel/tutup jika Ada perinta mencari file notebook karena memang kita baru mulai.

Masuk ke File – New Notebook. Di bagian atas ada tulisan Untitled0.ipynb yang merupakan file program yang akan tersimpan di Google (berlokasi di Google Drive). Isi sel dengan kode program pembelian barang berikut ini.


print(" ——Toko Amanah Jaya———-")
#input data
harga= int(input("masukan harga barang: "))
jumlah= int(input("masukan jumlah baju yang dibeli: "))
Total=harga*jumlah
print("Total Harga = ", "Rp.",Total)
Bayar=int(input("Jumlah Nominal Uang =" ))
Kembalian= (Bayar-Total)
print("Uang Kembalian = ", "Rp.",Kembalian)

Jalankan dan pastikan akan muncul proses interaktif memasukan data dan memproses pembayaran. Oiya, kalo copas tanda ” harus diketik ulang karena dianggap bukan tanda petik di Google Colab. Hasilnya sebagai berikut.

SIlahkan lihat video berikut untuk lebih jelasnya. Sekian, semoga bermanfaat.

Referensi:

Situs Coding: https://www.codepolitan.com/belajar-membuat-aplikasi-sederhana-dengan-python-3-7-4

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.