# 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.

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)
```
Iklan

# Studi Lanjut di Era New Normal

Untuk rekan-rekan yang saat ini masih kuliah (S1, S2, atau S3), pasti terpengaruh dengan wabah COVID-19. Yang biasanya bertatap muka, saat ini berganti melalui multimedia, baik tulisan, suara, maupun video. Tentu saja kesulitan pasti muncul. Repotnya kesulitan tersebut baru kali ini terjadi. Saya sendiri sulit membayangkan seandainya saya belum lulus. Sebagai informasi banyak rekan-rekan saya yang belum juga lulus. Mungkin postingan ini sedikit bisa memberi gambaran untuk rekan-rekan yang akan memulai studi. Untuk yang sedang berjalan, mungkin bisa sharing jika ada pengalaman yang bermanfaat untuk dibagikan.

Kondisi Universitas Saat Ini

Tanpa adanya COVID-19, beberapa pakar mulai mempertanyakan apakah universitas juga mengalami disrupsi, seperti perusahaan-perusahaan lainnya dimana terjadi pergeseran dari proses bisnis konvensional menjadi online. Dengan adanya wabah, apalagi jika antivirus belum juga ditemukan, proses disrupsi jauh lebih cepat lagi sepertinya. Ada perubahan dalam perhitungan dimana kondisi saat ini mengharuskan tiap universitas harus efisien dalam menggunakan sarana dan prasarana yang ada. Memang, serangan COVID-19 mirip serangan mendadak yang membuat pontang-panting dunia pendidikan yang baru saja siap-siap online. Beban berat ada di tangan divisi yang bertugas mengontrol jalannya perkuliahan online dan memastikan kualitas proses belajar tetap seperti kondisi sebelumnya. Persaingan yang ketat membuat kampus tidak boleh main-main dengan biaya karena calon siswa dengan mudah beralih ke kampus lain, apalagi kondisi saat ini informasi sangat mudah di dapat, termasuk informasi mengenai kinerja kampus tujuan.

Safe Mode

Ibarat sistem operasi yang bermasalah, terkadang perlu menjalankan mode “safe mode” dimana beberapa driver saja yang diaktifkan guna menghindari “crash”, begitu juga sebaiknya calon siswa bersikap. Pikirkan kembali apakah mengambil kuliah di dalam atau di luar negeri. Biaya sendiri atau menunggu beasiswa. Sempat juga saya ngobrol dengan pengelola S3 sistem informasi yang baru saja dibentuk. Saat ini skema yang ada hanyalah LPDP yang mungkin hanya beberapa yang dapat per angkatan (dua atau tiga). Jika biaya bisa dicover dari gaji atau tunjangan serdos, tidak ada salahnya menggunakan biaya sendiri. Atau jika masih ragu, tunda saja beberapa saat hingga kondisi wabah mereda. Untuk yg tinggal syarat wajib publikasi, jika diperbolehkan open akses yang berbayar tidak ada salahnya memilih opsi itu daripada gaya-gayaan milih murni Q1 atau Q2 dengan impak yang tinggi tapi ga tembus-tembus.

Metode Belajar

Saat ini calon mahasiswa dituntut kualitasnya mirip calon pegawai. Silahkan searching di internet, tuntutan apa saja yang diminta oleh perusahaan, terutama secara psikologis seperti kemampuan untuk berkembang, beradaptasi, berkolaborasi, berkomunikasi, dan sejenisnya. Jika dulu kita bisa seharian berfikir menyelesaikan masalah/problem, saat ini jika dengan kolaborasi lebih cepat, tidak ada salahnya gabung di grup-grup keilmuwan. Saat ini banyak grup-grup medsos yang membicarakan hal itu, tentu saja harus memiliki “sense” agar tidak hanyut ke hal-hal remeh temeh yang tidak perlu seperti politik, gosip, dan sejenisnya.

Result-based dengan memperhatikan konsep pareto (20:80) perlu juga dipelajari. Silahkan searching konsep menarik ini. Kita harus memiliki kemampuan mendeteksi 20 persen titik kritis yang mempengaruhi 80% hasil. Jangan sampai menghabiskan 80% yang tidak penting dan melupakan 20% yang vital. Mengapa hal ini penting? Salah satu alasannya adalah dunia online yang memiliki aplikasi-aplikasi yang memicu endorphin, seperti game, medsos, dan sejenisnya. Gunakan metode detoks dengan cara mengerjakan hal-hal wajib yang membosankan tapi penting, jadikan pemicu endorphin tersebut sebagai “hadiah” saja.

Di era “big data” ini, informasi sangat mudah dijumpai. Ada manfaat, tetapi tentu saja banyak informasi sampah yang tidak harus kita telan juga. Otak kita tidak seperti machine learning yang mampu mengelola data yang besar 24 jam. Oleh karena itu kemampuan mendeteksi informasi-informasi berharga harus dimiliki. Terkadang informasi tersebut tidak bisa diperoleh hanya dengan mengetik kata kunci di Google. Bisa saja lewat bacaan baik buku maupun jurnal. Khusus mahasiswa doktoral wajib menguasai hal ini mengingat syarat lulus yang harus menemukan hal unik yang baru (novelty).

Low Profile

Sungguh konyol kalau kita masih berani sombong dalam kondisi seperti ini. Negara2 adidaya saja kewalahan menghadapi kondisi saat ini. Kabarnya beberapa kampus di barat mengalami kekhawatiran akan tutup. Apalagi kita yang calon siswa, tentu saja kerendahan hati, sifat alami bangsa Indonesia, tetap dijaga. Tidak ada salahnya mengakui kalau kita tidak bisa dari pada tugas tidak selesai. Tidak ada salahnya juga membantu rekan-rekan tanpa imbalan.

Tetap Hidup

Nah ini yang penting. Ketika saya kuliah, terkadang otak bekerja keras siang malam. Makan dan tidur kurang, serta jarang berolah raga. Untuk kondisi new normal yang akan kita hadapi sebaiknya jangan dilakukan. Tidur yang cukup, berolah raga, dan makan makanan bergizi (tidak perlu mahal) harus dilakukan. Saya teringat ketika pembekalan sebelum berangkat kuliah ke luar, pembicara mengatakan agar jangan terlalu “perfect”. Kerjakan secepatnya, tidak perlu menghasilkan hal-hal yang “wah”, apalagi sampai ingin dapat hadiah nobel. Makin kita lama kuliah, makin banyak yang dikorbankan, terutama waktu yang tidak bisa dibeli. Semoga pembaca sehat selalu … Amiin.

[mk|pert|jur:logika-alg|X|akuntansi]

Banyak kita jumpai bahasa pemrograman dengan aturan tata-tulis (sintaks) yang beragam. Terkadang pengguna bahasa pemrograman tertentu kesulitan membaca kode yang dibuat oleh bahasa pemrograman lain, walaupun terkadang tidak terlalu berbeda jauh. Oleh karena itu dibutuhkan suatu aturan agar sebuah kode program dapat dimengerti oleh programer bahasa pemrograman lain. Walaupun disainer memiliki alat bantu berupa diagram, misalnya flowchart, activity diagram, dan model-model lainnya baik yang bersifat berorientasi objek maupun terstruktur, tetap bagi programer agak sulit, khususnya ketika berinteraksi lewat milis-milis, misalnya stackoverflow, github, dan grup-grup lainnya. Oleh karena itu beberapa peneliti menggunakan pseudocode untuk bertukar informasi sebuah kode program. Tentu saja bukan kode program seluruhnya, hanya beberapa bagian, biasanya sebuah fungsi atau kelas yang penting untuk dikomunikasikan, baik dalam artike ilmiah, maupun diskusi-diskusi di internet. Postingan kali ini mencoba memberikan gambaran bagaimana cara pembuatan pseudocode yang lazim digunakan.

1. Tipe input, output, proses

Tipe pertama merupakan pseudocode dengan fokus utama proses yang dilakukan terhadap sebuah masukan untuk menghasilkan keluaran tertentu. Di sini tidak dirinci apa format kode tersebut, apakah sebuah fungsi ataukah komputasi numerik tertentu yang merupakan bagian dari fungsi yang lebih besar. Gambarannya kira-kira seperti ini, misalnya diminta menghitung jarak antara satu data dengan data lainnya dengan Euclidean distance.

• ——————————————————-
• Algoritma 1: Menghitung Jarak Euclidean
• ——————————————————-
• input: x1,y1,x2,y2
• output: d
• d = sqrt((x1-x2)^2+(y1-y2)^2)
• ——————————————————–

Jenis ini terkadang tidak tidak menyertakan output di atas, tetapi meletakan Return di bagian bawah yang menggambarkan jarak.

• ——————————————————-
• Algoritma 1: Menghitung Jarak Euclidean
• ——————————————————-
• input: x1,y1,x2,y2
• d = sqrt((x1-x2)^2+(y1-y2)^2)
• return d
• ——————————————————–

Kebetulan di sini merupakan fungsi sederhana yang tidak melibatkan kalang (loop). Ada dua jenis kalang yang biasa digunakan dalam pseudocode yaitu for – next dan repeat – until. Selain itu ada juga while – end yang masuk kategori repeat-until. Diletakan di antara input dan output. Terkadang di sisi proses tidak dijelaskan secara detil, hanya garis besar saja jika dirasa pembaca sudah mengetahui alur komputasi atau fungsi yang biasa digunakan secara umum.

2. Tipe Fungsi

Fungsi merupakan komponen kecil dari total kode program, baik yang berada dalam satu file dengan fungsi induk maupun yang terpisah. Pseudocode tipe ini biasa digunakan oleh pengguna Matlab dan Python. Jika Matlab menggunakan kata kunci “Function”, Python dengan “def” (lihat pos yang lalu tentang fungsi eksternal). Fungsi melibatkan nama fungsi serta variabel masukan. Misal untuk contoh kasus perhitungan jarak Euclidean seperti kasus sebelumnya.

• ——————————————————-
• Function jarak(x1,x2,y1,y2)
• ——————————————————-
• input: x1,y1,x2,y2
• d ← sqrt((x1-x2)^2+(y1-y2)^2)
• return d
• ——————————————————–

Biasanya notasi pseudocode tidak menggunakan sama dengan “=” melainkan panah kiri “← “. Mengenai apakah pseudocode itu jenis tulisan atau gambar, ada beragam versi. Ada yang membuat kotak pada pseudocode dan menjelaskannya sebagai gambar, ada juga yang menganggap sebagai tulisan biasa bagian dari artikel. Mungkin pembaca menemukan bentuk lainnya.

# Memanggil Fungsi Eksternal Pada Python

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.

# 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
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 Activity Diagram dengan Microsoft Visio

Aktivity diagram merupakan salah satu diagram Unified Modeling Language (UML). Diagram ini menjelaskan lebih rinci diagram use-case dalam bentuk alur aktivitas. Selain itu, diagram ini menyediakan pula sebuah swimlane yaitu alur yang menggambarkan bagian/divisi yang bekerja. Di sini kita coba menggambar diagram activity dengan Microsoft Visio. Berbeda dengan Excel dan Access yang satu paket dengan microsoft office, microsoft visio berbeda paket dan harus membeli lisensi tambahan untuk aplikasi ini. Buka Visio dan kita buat diagram baru.

Pada bagian more shapes pilih software & database – Software – UML Activity. Tampak diagram-diagram yang digunakan oleh diagram activity muncul di bagian kiri visio. Klik, tahan dan pindahan diagram ke lembar kerja visio. Yang pertama-tama adalah Swimlane, yang berupa persegi panjang vertikal.

Untuk menambah aktor tekan dua kali di sisi kanan Swimlane untuk menambah. Di sini untuk aktivitas tertentu terkadang berisi divisi atau bagian dimana sebuah aktivitas berlangsung. Ganti nama Function menjadi nama yang sesuai.

Sedikit tip n trik, ketika membuat satu activity baru, lebih enak dengan copas dari yang ada agar ukurannya tidak perlu diseting lagi. Untuk penentuan posisi, ikut arah garis pemandu agar ketika membuat garis panah akar lurus tepat di “pin” pada activity. Berikutnya sediakan beberapa konektor berupa garis berarah panah.

Secara default, garis konektor tidak memiliki panah. Jadi kita harus menambahkan panah dengan cara mengklik kanan garis konektor dan klik format shape.

Sekarang konektor sudah memiliki panah/arah. Berikutnya tidak perlu melakukan langkah itu lagi karena kita tinggal meng-copy-paste saja konektor yang sudah memiliki panah. Berikutnya buat diagram activity Anda hingga selesai.

Pada diagram activity terdapat juga decision berupa belah ketupat. Di sini pertanyaan tidak berada di dalam belah ketupat, melainkan di luar. Ada baiknya juga tulisan di luar belah ketupat, bentuk belah ketupat jadi tidak terlalu besar. Jika masuk satu keluar dua, disebut decision, sebaliknya disebut merge. Cukup mudah bukan? Selamat mencoba.

# 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.