Rahmania Azwarini

Klasifikasi dengan Algoritma C4.5

Leave a Comment / Deskripsi / Rahmania Azwarini / November 19, 2025

Algoritma C4.5 — Halo halo sobat Exsight, dalam era big data seperti sekarang ini, tentunya kita dibanjiri oleh jutaan informasi setiap detik nya. Data hadir dalam berbagai bentuk seperti transaksi belanja, riwayat kesehatan, aktivitas media sosial, dan berbagai hal lainnya yang menerapkan Internet of Things (IoT). Namun, data yang melimpah tidak akan memberi manfaat jika hanya disimpan begitu saja. Tantangan utamanya adalah bagaimana mengubah data mentah tersebut menjadi knowledge yang bisa membantu pengambilan keputusan.

Salah satu pendekatan populer dalam data mining adalah metode klasifikasi. Di antara sekian banyak algoritma klasifikasi, pohon keputusan (decision tree) menjadi favorit karena hasilnya mudah dipahami oleh peneliti. Dari berbagai varian pohon keputusan, algoritma C4.5 menempati posisi penting. Algoritma C4.5 banyak digunakan dalam berbagai bidang, mulai dari memprediksi kelayakan kredit nasabah, mengidentifikasi penyakit berdasarkan gejala pasien, hingga memutuskan strategi pemasaran yang tepat.

Dalam artikel ini, kita akan membahas lebih mendalam mengenai konsep dasar, tahapan kerja, kelebihan dan kelemahan, hingga contoh penerapan algoritma C4.5. Dengan memahami algoritma ini, kita bisa melihat bagaimana data yang kompleks dapat diubah menjadi suatu dasar dalam analisis statistik, khususnya dalam pengambilan keputusan di kehidupan nyata.

Konsep Dasar Teori

Algoritma C4.5 adalah salah satu metode populer dalam machine learning yang digunakan untuk membuat pohon keputusan (decision tree). Sehingga dalam hal ini untuk memahami C4.5, kita perlu paham terlebih dahulu mengenai konsep dasar decision tree.

Pohon Keputusan (Decision Tree)

Pohon keputusan (decision tree) merupakan salah satu metode dalam pemodelan prediktif yang bisa dipakai untuk dua tujuan utama: mengklasifikasikan data maupun melakukan prediksi. Prinsip yang digunakan adalah divide and conquer atau “membagi lalu menyelesaikan”, yaitu dengan memecah permasalahan besar menjadi bagian-bagian yang lebih kecil dan sederhana

Dalam penerapannya, data yang semula berbentuk tabel diolah menjadi sebuah struktur menyerupai pohon. Dari pohon ini akan dihasilkan aturan-aturan (rules) yang dapat dipakai untuk menarik kesimpulan, dan aturan tersebut biasanya diringkas agar lebih mudah dipahami.

Secara umum, pohon keputusan (decision tree) adalah salah satu metode klasifikasi terhadap objek atau record. Struktur pohonnya terdiri dari simpul keputusan (decision node) yang saling terhubung dengan cabang, dimulai dari simpul akar (root node) dan berakhir pada simpul daun (leaf node) sebagai hasil akhir klasifikasi. Ilustrasi dari konsep dasar Pohon Keputusan (Decision Tree) ditampilkan sebagaimana gambar berikut.

Berdasarkan gambar di atas, pada decision tree, terdapat 3 jenis node, yaitu:

a. Root Node
Merupakan node paling atas. Pada node ini tidak ada input dan bisa tidak mempunyai output atau pun mempunyai output lebih dari satu.
b. Internal Node
Merupakan node percabangan. Pada node ini hanya terdapat satu input dan mempunyai output minimal dua.
c. Leaf Node atau Terminal Node
Merupakan node akhir. Pada node ini hanya terdapat satu input dan tidak mempunyai output.

Tahapan Algoritma C4.5

1. Menentukan Target (Kelas yang Akan Diprediksi)
Menentukan terlebih dahulu variabel mana yang ingin diprediksi. Contoh: “Apakah mahasiswa lulus tepat waktu atau tidak”, atau “Apakah pelanggan membeli produk atau tidak”.

2. Mempersiapkan Data Training
Data latih atau data training berisi data-data yang sudah dikelompokkan dalam kelas-kelas tertentu. Data training dapat diambil berdasarkan data historis yang pernah terjadi sebelumnya.

3. Menghitung Nilai Entropy (Nilai Ketidakpastian Data)
Nilai Entropy menunjukkan seberapa banyak informasi yang dibutuhkan untuk menjelaskan suatu data; jika semua data sudah pasti dalam satu kelas maka entropy = 0 karena tak perlu informasi tambahan, tetapi jika data masih beragam antar kelas maka entropy meningkat karena ketidakpastian atau kebingungan untuk menentukan kelasnya juga makin besar.

Adapun rumus yang digunakan untuk menghitung nilai entropy yaitu

Entropy\left( S \right)=\sum_{i=1}^{n}-p_{i}log_{2}\left( p_{i} \right)

Keterangan:
S = Himpunan kasus
n = Jumlah partisi S
p_i = Proporsi S_iterhadap S

3. Menghitung Information Gain untuk Tiap Atribut
Information Gain adalah ukuran seberapa besar pengurangan ketidakpastian (entropy) setelah data dibagi berdasarkan suatu atribut. Semakin besar nilai Information Gain, semakin banyak “informasi baru” yang kita dapat dari atribut itu, artinya atribut tersebut sangat membantu untuk memisahkan data ke dalam kelas yang benar. Atribut dengan Information Gain besar berarti sangat membantu memisahkan kelas.

Gain\left( S,A \right)=Entropy\left( S \right)-\sum_{i=1}^{n}\frac{\left| S_{i} \right|}{\left| S \right|}Entropy\left( S_{i} \right)

Keterangan:
S = Himpunan kasus
A = Atribut
n = Jumlah partisi atribut A
|S_i| = Jumlah kasus pada partisi ke-i
|S| = Jumlah kasus dalam S

4. Membagi Dataset Berdasarkan Atribut yang Terpilih
Dataset dibagi menjadi cabang-cabang sesuai nilai atribut yang dipilih. Jika atributnya numerik (kontinu), algoritma C4.5 akan menentukan threshold (misalnya: “Umur ≤ 25” dan “Umur > 25”).

5. Mengulangi Proses
Pada tiap cabang, langkah 2 sampai dengan langkah 4 diulang kembali dengan data subset, sampai semua data dalam cabang sudah homogen (satu kelas), atau tidak ada atribut yang tersisa.

6. Menangani Missing Value
Jika ada data yang hilang, algoritma C4.5 akan tetap bisa bekerja dengan memberikan probabilitas ke tiap cabang berdasarkan distribusi data yang ada.

7. Melakukan Proses Pruning (Pemangkasan Pohon)
Setelah pohon terbentuk, algoritma C4.5 melakukan pemangkasan (pruning) untuk mengurangi kompleksitas pohon. Tujuannya agar pohon tidak terlalu bergantung dengan data latih (overfitting) dan lebih mampu melakukan generalisasi pada data baru.

Kelebihan dan Kelemahan

Kelebihan

Dapat Menangani Variabel Kontinu dan Diskrit
Algoritma C4.5 bisa bekerja pada atribut diskrit maupun kontinu dengan melakukan pembagian (threshold) otomatis saat membangun pohon.
Menangani Data yang Terdapat Nilai Hilang (Missing Values)
Algoritma ini memiliki mekanisme untuk tetap menggunakan data yang memiliki atribut yang hilang, sehingga tidak perlu membuang data.
Algoritma C4.5 Mudah Diinterpretasikan
Karena algoritma C4.5 menghasilkan pohon keputusan, aturan-aturan (“if … then …”) yang dihasilkan relatif jelas dan mudah dipahami.
Memiliki Mekanisme Pruning
Untuk menghindari adanya overfitting, dalam algoritma C4.5 dilakukan pruning pohon keputusan sehingga model tidak terlalu kompleks dan secara generalisasi bisa lebih baik.
Dapat Digunakan dalam Berbagai Bidang
Banyak penelitian empiris menunjukkan bahwa algoritma C4.5 memberikan hasil evaluasi akurasi dan recall yang tinggi dalam tugas klasifikasi di berbagai bidang (kesehatan, kepuasan pelanggan, status gizi, dll.).

Kelemahan

Kebutuhan komputasi yang lebih besar
Karena harus menghitung gain ratio, menangani atribut kontinu, menangani missing value atau nilai hilang, dan melakukan pruning, maka perhitungan menjadi lebih berat dibanding algoritma yang lebih sederhana.
Rentan terhadap Overfitting bila Pruning kurang tepat
Jika pohon terlalu dalam dan terlalu banyak percabangan tanpa pruning yang memadai, bisa jadi pohon model terlalu cocok dengan data training tapi buruk dalam generalisasi data baru.
Interpretasi Bisa Menjadi Sulit Ketika Pohonnya Sangat Besar
Meski aturan umumnya mudah dibaca, jika pohonnya memiliki banyak cabang dan kedalaman, membaca seluruh pohon bisa menjadi rumit dan aturan bisa banyak sekali.
Kinerja Mungkin Kurang Optimal jika Data Sangat Besar atau Sangat Banyak Variabel
Untuk dataset yang sangat besar dan fitur banyak, waktu pelatihan bisa menjadi lama, dan penggunaan memori bisa tinggi.

Penerapan Algoritma C4.5

Misalnya kita ingin memprediksi apakah seseorang akan membeli asuransi jiwa atau tidak, berdasarkan beberapa atribut:

No	Usia	Penghasilan	Status Keluarga	Beli Asuransi
1	Muda	Rendah	Lajang	Tidak
2	Muda	Tinggi	Menikah	Ya
3	Dewasa	Sedang	Menikah	Ya
4	Dewasa	Tinggi	Lajang	Ya
5	Tua	Sedang	Menikah	Ya
6	Tua	Rendah	Lajang	Tidak

Penyelesaian:
Berdasarkan tabel di atas, terdapat total 6 data, dimana 4 orang membeli asuransi dan 2 orang tidak membeli asuransi. Tahapan pertama dilakukan perhitungan entropy awal (S) sebagai berikut.

Entropy\left( S \right)=-\left( \frac{4}{6}log_{2}\frac{4}{6}+\frac{2}{6}log_{2}\frac{2}{6} \right)=0.918

Berdasarkan perhitungan nilai entropy awal (S) di atas dapat diartikan bahwa sebelum dipisahkan, data masih cukup acak atau belum pasti.

Selanjutnya dilakukan perhitungan nilai entropy untuk setiap atribut (Usia, Penghasilan, Status Keluarga).

ATRIBUT USIA
*Usia Muda
Total jumlah responden berusia muda pada tabel yaitu 2 orang, dimana 1 membeli asuransi (ya) dan 1 tidak.

\begin{matrix} p\left( Ya \right)=\frac{1}{2}=0.5,\text{ }p\left( Tidak \right)=\frac{1}{2}=0.5\\ Entropy\left( Muda \right)=-\left[ 0.5log_{2}\left( 0.5 \right)+ 0.5log_{2}\left( 0.5 \right) \right]=1 \end{matrix}

*Usia Dewasa
Total jumlah responden berusia dewasa pada tabel yaitu 2 orang, dimana keduanya membeli asuransi (ya)

\begin{matrix} p\left( Ya \right)=\frac{2}{2}=1,\text{ }p\left( Tidak \right)=\frac{0}{2}=0\\ Entropy\left( Muda \right)=-\left[ 1log_{2}\left( 1\right)+ 0log_{2}\left( 0 \right) \right]=0 \end{matrix}

*Usia Tua
Total jumlah responden berusia tua pada tabel yaitu 2 orang, dimana 1 membeli asuransi (ya) dan 1 tidak.

\begin{matrix} p\left( Ya \right)=\frac{1}{2}=0.5,\text{ }p\left( Tidak \right)=\frac{1}{2}=0.5\\ Entropy\left( Tua \right)=-\left[ 0.5log_{2}\left( 0.5 \right)+ 0.5log_{2}\left( 0.5 \right) \right]=1 \end{matrix}

Selanjutnya setelah mengetahui nilai entropy untuk atribut usia muda, dewasa, dan tua, dilakukan perhitungan rata-rata entropy (Weighted Average) untuk entropy usia.

Entropy\left( Usia \right)=\frac{2}{6}\left( 1 \right)+\frac{2}{6}\left( 0 \right)+\frac{2}{6}\left( 1 \right)=0.667

Setelah mendapatkan nilai rata-rata entropy Usia sebesar 0.667, berikutnya dilakukan perhitungan Information Gain untuk atribut Usia

\text{Information Gain (Usia)}=0.918-0.667=0.251

Tahapan berikutnya, dengan cara yang sama dihitung pula masing-masing nilai entropy dan information gain untuk atribut Penghasilan dan atribut Status Keluarga

ATRIBUT PENGHASILAN

Penghasilan Rendah dimana semua “Tidak Membeli Asuransi” maka Entropy = 0
Penghasilan Sedang dimana semua “Ya (Membeli Asuransi)” maka Entropy = 0
Penghasilan Tinggi dimana semua “Ya (Membeli Asuransi)” maka Entropy = 0

Rata-rata Entropy(Penghasilan) = 0
sehingga didapatkan
Information Gain(Penghasilan) = 0.918 – 0 = 0.918

ATRIBUT STATUS KELUARGA

Status Lajang dimana 1 orang Ya (Membeli Asuransi), 2 orang Tidak Membeli Asuransi maka Entropy = 0.918
Status Menikah dimana semua Ya (Membeli Asuransi) maka Entropy = 0

Rata-rata Entropy(Status Keluarga) = 0.459
sehingga didapatkan
Information Gain(Penghasilan) = 0.918 – 0.459 = 0.459

Setelah dilakukan perhitungan Information Gain untuk masing-masing atribut, diketahui bahwa atribut dengan Information Gain tertinggi yaitu atribut Penghasilan. Maka untuk atribut Penghasilan, paling baik untuk dijadikan node pertama (root) dalam pohon keputusan (decision tree)

Interpretasi dari hasil perhitungan berdasarkan atribut Penghasilan sebagai root yaitu

Jika penghasilan rendah, kemungkinan responden kedepannya tidak beli asuransi.
Jika penghasilan sedang ataupun tinggi , maka kemungkinan responden kedepannya beli asuransi.

Referensi

Tukino. (2019). Penerapan Algoritma C4.5 untuk Memprediksi Keuntungan pada PT SMOE Indonesia. Jurnal Sistem Informasi Bisnis.

Pambudi, R. (2018). Penerapan Algoritma C4.5 untuk Memprediksi Nilai Kelulusan Siswa Sekolah Menengah Berdasarkan Faktor Eksternal. Jurnal Pengembangan Teknologi Informasi dan Ilmu Komputer, Vol.2, No.7.

Nah, sampai juga kita di akhir artikel. Sampai disini dulu penjelasan terkait Klasifikasi dengan Algoritma C4.5. Jika masih ada yang dibingungkan atau ada yang ingin didiskusikan, bisa langsung saja ramaikan kolom komentar atau hubungi admin melalui tombol bantuan di kanan bawah. Stay tuned di website https://exsight.id/blog/ agar tidak ketinggalan artikel-artikel menarik lainnya. See you!

Klasifikasi dengan Algoritma C4.5 Read More »

Brownian Motion dalam Proses Stokastik

Leave a Comment / Deskripsi / Rahmania Azwarini / October 1, 2025

Brownian Motion – Sobat Exsight pernah gak sih membayangkan bagaimana debu halus di permukaan air terus bergerak tanpa pola yang jelas?

Fenomena gerakan acak partikel-partikel ini pertama kali diamati oleh Robert Brown pada abad ke-19 dan hingga kini dikenal sebagai Brownian Motion. Di balik gerakan yang sederhana tersebut, tersimpan dasar matematika dan statistika yang sangat penting terutama dalam bidang teori stokastik. Dalam artikel kali ini, kita akan mengulas secara dalam konsep dasar dari Brownian Motion, formulasi matematisnya, serta bagaimana model Brownian Motion ini diterapkan untuk memahami berbagai fenomena nyata yang sifatnya tak terduga.

Definisi

Brownian Motion termasuk bagian dari proses stokastik. Adapun proses stokastik merupakan sekumpulan variabel acak yang berubah terhadap waktu. Sebagai permisalan, dalam konteks ekonomi kita dapat lihat pergerakan harga saham yang mana pergerakannya acak dari waktu ke waktu. Contoh lainnya yaitu pergerakan partikel debu di udara dimana ini bergerak secara acak. Kedua contoh pergerakan acak ini dapat dimodelkan dengan proses stokastik.

Jika waktunya dihitung per langkah (misalnya detik ke-1, detik ke-2, dst) hal ini disebut dengan proses stokastik diskrit.
Jika waktunya dianggap berjalan terus menerus (misalnya setiap saat sepanjang waktu) hal ini disebut proses stokastik kontinu.

Brownian Motion atau Gerak Brown adalah salah satu contoh proses stokastik kontinu. Secara sederhana, gerak Brown menggambarkan pegerakan acak seperti halnya partikel kecil yang melayang dalam fluida (seperti debu di udara atau serbuk di dalam air).

Konsep Dasar

Terdapat berbagai jenis Brownian Motion, diantaranya yaitu Brownian Motion, Brownian Motion Standar, Brownian Motion dengan Drift, Brownian Motion Geometri.

a. Brownian Motion

Sebuah proses stokastik disebut Brownian Motion jika memenuhi syarat sebagai berikut:

W(0) = 0 yang artinya di awal waktu, posisi partikel dimulai dari titik nol.
Untuk setiap waktu 0 ≤ s ≤ t ≤ T , perubahan posisi W(t) – W(s) berdistribusi normal dengan rata- rata 0 dan varians σ²(t−s) . Artinya gerakan partikel bersifat acak, namun kita tahu bahwa sebarannya mengikuti distribusi normal.
Untuk interval waktu 0 ≤ s < t < u < v ≤ T yang tidak tumpang tindih, perubahan posisi partikel saling independen. Artinya apa yang terjadi di periode sebelumnya tidak memengaruhi periode sesudahnya.

**b. Brownian Motion Standar**

Selanjutnya proses stokastik disebut Brownian Motion Standar jika memenuhi syarat sebagai berikut:

W(0) = 0 dimana waktu dimulai dari nol.
Distribusi normal dari perubahan posisi W(t) – W(s) untuk setiap waktu 0 ≤ s ≤ t ≤ T berdistribusi normal memiliki rata- rata 0 dan varians (t-s) . Sebagai catatan varians t-s didapatkan dari σ²(t−s) yang mana σ² = 1 sehingga variansnya menjadi t-s .
Perubahan di interval waktu yang berbeda juga saling independen.
Berupa pergerakan acak murni tanpa arah rata-rata.

Beberapa contoh penerapan gerakan brown standar diantaranya:

Bidang Aktuaria
Dalam aktuaria, kita sering menghadapi klaim asuransi kecil (misalnya klaim kesehatan rawat jalan). Jumlah klaim tiap hari/minggu tidak bisa diprediksi secara pasti, tetapi jika diamati dalam jangka panjang, pola kenaikannya acak dan dapat dimodelkan dengan Brownian Motion Standar. Dengan model ini, perusahaan asuransi bisa memperkirakan risiko agregat klaim meskipun masing-masing klaim sangat random.

Contoh Kasus:
Misalkan diketahui bahwa jumlah klaim asuransi rawat jalan di suatu perusahaan asuransi dimodelkan dengan Brownian Motion Standar W(t). Jika dalam 10 hari, klaim dimulai dari 0, maka distribusi jumlah klaim yaitu:

Jawab:
Hari demi hari, klaim berfluktuasi secara acak, diambil permisalan ditinjau pada hari ke 1, hari ke 5, dan hari ke 10 sebagai berikut.
* Pada hari ke 1, distribusi W(1) ~ N(0, 1)
* Pada hari ke 5, distribusi W(5) ~ N(0, 5)
* Pada hari ke 10, distribusi W(10) ~ N(0, 10)
Varians makin besar seiring waktu (bertambah linear terhadap t), dengan kata lain semakin lama periode waktu, maka semakin besar ketidakpastian (varians).

Jadi di hari ke-10, ketidakpastiannya 10 kali lebih besar dibandingkan hari pertama. Proses ini bersifat memoryless increment dengan kata lain tambahan klaim antar periode waktu saling bersifat independen satu sama lain.

Bidang Ekonomi
Contoh penerapan lain dari Brownian Motion dalam bidang ekonomi yakni dapat digunakan untuk menjelaskan fluktuasi jangka pendek harga komoditas yang tidak punya tren jelas, hanya naik-turun secara acak.

c. Brownian Motion dengan Drift

Suatu proses Brownian Motion dikatakan sebagai Bownian Motion Drift apabila terdapat komponen drift μ(t) pada gerak brown standar. Selain itu pada brownian motion dengan drift terdapat pergerakan acak tetapi ada arah rata-rata (misalnya tren naik). Adapun persamaan yang dibentuk dari gerak Brown drift yaitu

B(t)=\mu(t)+\sigma W(t)

\begin{matrix} dengan \\ \mu(t)=\text{Tren rata - rata (bisa dianggap arah pergerakan jangka panjang)} \\ \sigma=\text{Standar deviasi atau besar penyimpangan dari proses t} \\ W(t)=\text{Komponen acak dari Gerak Brown Standar} \end{matrix}

\text{Adapun }W(t)=Z\sqrt{t}\text{ di mana Z adalah bilangan random dari Distribusi Normal Standar}

Beberapa contoh penerapan gerakan brown dengan drift diantaranya:

Bidang Aktuaria
Dalam bidang Aktuaria dapat dipakai untuk memprediksi perkembangan nilai aset dana pensiun yang cenderung tumbuh seiring waktu, tetapi tetap berisiko karena ada fluktuasi pasar.

Contoh Kasus:
Suatu dana pensiun dimulai dengan nilai awal 100 miliar, diasumsikan mengikuti model Brownian Motion dengan drift. Diketahui nilai rata- rata return tahunan 6 %, besar nilai volatilitas 15 %. Bagaimana distribusi nilai return setelah 5 tahun?

Jawab:
Dana pensiun diasumsikan mengikuti model Brownian Motion dengan Drift dengan nilai awal 100 miliar. Adapun rumus yang digunakan yaitu

B(t)=\mu(t)+\sigma W(t) \text{ dengan}

\begin{matrix} \mu =0.06 \\ \sigma=0.15 \\ t=5 \end{matrix}

\begin{matrix} \text{Distribusi yang terbentuk }B\left( t \right)\sim N\left( \mu t,\sigma^{2}t \right) \\ \text{Maka} \\ B\left( 5 \right)\sim N\left( 0.06\text{ . 5},\left(0.15\right)^{2}\text{ .5} \right)\\ B\left( 5 \right)\sim N\left( 0.30,0.1125 \right) \end{matrix}

Dalam 5 tahun, rata-rata dana pensiun diperkirakan tumbuh 30%. Namun fluktuasinya besar dilihat dari simpangan baku log-return = 33.5%. Probabilitas nilai log-return negatif (kerugian) bisa dihitung sebagai berikut

P\left( B\left( 5 \right)<0 \right)=P\left( Z<\frac{0-0.30}{0.335} \right)=P\left( Z< -0.896 \right)\sim 18.5\ persen

Jadi meski tren naik, ada 18.5% risiko penurunan nilai dalam 5 tahun.

Berdasarkan hasil ini terlihat jelas perbedaan antara Gerak Brown standar dan Gerak Brown dengan Drift, yaitu Gerak Brown Standar hanya acak, tidak ada arah. Sedangkan untuk Gerak Brown Drift terdapat arah rata-rata (tren naik/turun), tapi tetap ada ketidakpastian dari komponen acaknya.

Bidang Ekonomi
Dalam bidang Ekonomi cocok untuk menggambarkan pertumbuhan PDB (Produk Domestik Bruto) suatu negara yang rata-rata naik tiap tahun, meski kadang ada guncangan acak.

Sama seperti contoh kasus sebelumnya dalam hal ini rata- rata pertumbuhan PDB (misalnya 5% per tahun) dilambangkan dengan miu, sedangkan untuk guncangan ekonomi (seperti resesi, krisis ekonomi, pandemi, dan lainnya) dilambangkan dengan sigma. Melalui Brownian Motion dengan Drift dapat digambarkan Produk Domestik Bruto suatu negara cenderung naik dalam jangka panjang, namun tidak secara mulus.

**d. Brownian Motion Geometri**

Selanjutnya terdapat versi khusus dari Brownian Motion dengan Drift yang sangat sering dipakai dalam keuangan, yakni Brownian Motion Geometri. Dalam hal ini penerapannya, bukan berdasarkan harga langsung, tetapi return (persentase perubahan harga). Return dianggap acak tapi mengikuti distribusi log-normal.

Dalam dunia keuangan, harga saham atau aset sering bergerak naik turun secara acak. Kadang harga naik karena ada berita baik, kadang turun karena kondisi pasar memburuk. Untuk memahami pola pergerakan yang acak ini, para peneliti menggunakan model matematika. Salah satu model yang paling terkenal adalah Gerak Brown Geometri. Gerak Brown Geometri pada dasarnya adalah perpaduan antara tren rata-rata (drift) dan gerakan acak (fluktuasi/volatilitas). Model ini memastikan bahwa harga saham selalu bernilai positif, karena dalam kenyataannya harga saham tidak mungkin negatif. Adapun rumus umum dari Brownian Motion Geometri yaitu sebagai berikut.

B\left( t \right)=\mu^*\left( t \right)+\sigma W\left( t \right)\text{ dengan }t\ge 0

\begin{matrix} \text{dimana terdapat pula parameter drift }\mu^{*}\left( t \right)=\mu-\frac{1}{2}\sigma^{2} \\ \text{ dan parameter varian }\sigma^{2} \\ \text{ Serta terdapat pula W(t) yang merupakan proses Gerak Brown yang dimulai pada W(0)=0} \end{matrix}

Suatu proses stokastik pada pemodelan harga saham disebut Gerak Brown Geometrik jika

B\left( t \right)=ln\frac{P\left( t \right)}{P\left( t-1 \right)}

dengan B(t) merupakan return saham pada waktu ke-t. Atau dapat diartikan pula bahwa B(t) adalah return saham (log-return), yaitu persentase perubahan harga saham dari waktu ke waktu. Adapun P(t) merupakan harga saham pada waktu ke-t (harga sekarang atau current price). Sedangkan P(t−1) merupakan harga saham pada waktu sebelumnya (satu periode sebelum t).

Mengapa dalam Gerak Brown Geometri menggunakan Log return?
Hal ini dikarenakan pertumbuhan harga saham bisa dimodelkan selalu positif (karena harga saham tidak mungkin negatif). Lalu Log-return lebih stabil secara statistik (lebih mudah dianalisis).

Beberapa contoh penerapan gerakan brown geometri diantaranya:

Bidang Statistik
Dalam bidang statistik, Gerak Brownian Geometri digunakan sebagai dasar untuk simulasi Monte Carlo misalnya untuk kasus harga saham. Hal ini dikarenakan Gerak Brownian mempunyai sifat sesuai dengan pasar, yaitu harga selalu positif dan ada volatilitas (acak). Contoh: Membuat simulasi ribuan jalur harga saham 1 tahun ke depan untuk menghitung probabilitas harga saham mencapai target tertentu.

Bidang Aktuaria
Dalam bidang aktuaria dapat digunakan untuk penentuan harga opsi (option pricing) dengan model Black-Scholes. Dalam Black-Scholes, asumsi harga saham mengikuti GBM sehingga harga opsi bisa dihitung dengan formula tertutup. Contoh: Menghitung harga opsi beli (call option) saham perusahaan X dengan jatuh tempo 6 bulan.

Bidang Ekonomi
Dalam bidang ekonomi digunakan untuk memodelkan pergerakan harga saham di bursa efek, misalnya untuk analisis, manajemen risiko portofolio investasi dimana Log-return saham lebih stabil secara statistik dibanding return biasa, sehingga analisis risiko (misalnya Value-at-Risk) lebih akurat. Contoh: Investor ingin tahu risiko kerugian portofolio dalam 10 hari ke depan, maka harga saham dimodelkan dengan Gerak Brown Geometri.

Referensi

Taylor, H. M. (1998). An Introduction to Stochastic Modelling. Academic Press, Tokyo.

Khoir, N., Maruddani, D., & Ispriyanti, D. (2022). Prediksi Harga Saham Menggunakan Geometric Brownian Motion With Jump Diffusion Dan Analisis Risiko dengan Expected Shortfall (Studi Kasus: Harga Penutupan Saham PT. Waskita. Jurnal Gaussian, Vol.11, No.1.

Nah, itu dia penjelasan terkait Brownian Motion dalam Proses Stokastik. Jika masih ada yang dibingungkan atau ada yang ingin didiskusikan, bisa langsung saja ramaikan kolom komentar atau hubungi admin melalui tombol bantuan di kanan bawah. Stay tuned di website https://exsight.id/blog/ agar tidak ketinggalan artikel-artikel menarik lainnya. See you!

Brownian Motion dalam Proses Stokastik Read More »

Algoritma Genetika (Tutorial Python) – Part 2

Leave a Comment / Tutorial, Python / Rahmania Azwarini / August 6, 2025

Halo halo sobat Exsight, masih ingat nggak nih, pada artikel yang lalu kita pernah membahas terkait algoritma genetika, bisa dicek nih pada artikel Algoritma Genetika (Part 1). Nah sekarang, kita akan coba mengaplikasikan algoritma genetika dengan menggunakan case study yang nantinya akan diaplikasikan pada bahasa pemgrograman Python.

Algoritma Genetika (GA) adalah teknik optimasi berbasis seleksi alam yang meniru proses evolusi biologis. GA terdiri dari langkah-langkah berikut:

Inisialisasi populasi (random solusi)
Evaluasi (fungsi fitness)
Seleksi (memilih individu terbaik)
Crossover (kombinasi dua individu)
Mutasi (perubahan kecil pada individu)
Iterasi hingga konvergen

Tutorial Python

Studi Kasus

Dalam artikel ini, kita akan mencoba melakukan algoritma genetika dengan menggunakan bantuan Python.
Studi kasus yang akan kita gunakan dalam hal ini berkaitan dengan implementasi Algoritma Genetika (GA) untuk optimasi rute perjalanan, yaitu mengenai Travelling Salesman Problem (TSP)

Dalam hal ini
*Terdapat seorang penjual keliling (“salesman“) dan ia harus mengunjungi banyak kota.
Bagaimana cara nya agar salesman tersebut dapat keliling semua kota satu kali, lalu kembali ke kota awal, dengan rute terpendek?”

Sebagai catatan:
– Mengunjungi semua kota tepat sekali (tidak boleh bolak-balik)
– Lalu kembali lagi ke kota asal.
– Dengan jarak perjalanan sependek mungkin.

Load Library Python

Tahapan paling awal sebelum melakukan running syntax di Python yaitu melakukan load library. Apabila sobat Exsight masih belum memiliki library untuk algoritma genetika, maka dapat menginstall terlebih dahulu dengan cara.

pip install (nama library nya)

Adapun beberapa library yang digunakan terdiri atas:

import random
import math
import matplotlib.pyplot as plt

Penjelasan dari library di atas diantaranya yaitu:
* random → Untuk mengacak urutan kota (mutasi dan populasi awal).
* math → Untuk menghitung jarak (menggunakan rumus Pythagoras).
* matplotlib.pyplot (plt) → Untuk membuat gambar/visualisasi rute perjalanan kota.

Membuat Daftar Kota

Selanjutnya kita akan membuat list daftar kota yang nantinya akan dilalui oleh Salesman. Misalnya kita simbolkan Kota 0, Kota 1, Kota 2, Kota 3, dan Kota 4

cities = {
    0: (0, 0),
    1: (1, 5),
    2: (5, 2),
    3: (6, 6),
    4: (8, 3)
}

Dalam hal ini, list daftar kota dijadikan dalam 1 variabel, yaitu cities. Setiap kota punya nomor (0,1,2,…) dan lokasi koordinat (x, y).
Contoh: Kota 0 ada di titik (0,0), kota 1 di (1,5), kota 2 terdapat di titik (5,2) , kota 3 ada di koordinat (6,6) serta kota 4 terdapat di koordinat (8,3).

Menghitung Jarak Antara Dua Kota

Tahapan berikutnya kita akan menghitung jarak antara dua kota menggunakan fungsi distance. Adapun perhitungan jarak antara dua kota secara manual menggunakan rumus:

Distance=\sqrt{((x_{2}-x_{1})² + (y_{2}-y_{1})²)}

Rumus ini disebut rumus jarak Euclidean (jarak lurus), sama seperti jika kita mengukur jarak antara dua titik di kertas atau peta dengan penggaris, dalam hal ini
* x₁ dan y₁ adalah koordinat kota pertama
* x₂ dan y₂ adalah koordinat kota kedua

Adapun dalam hal ini, perhitungan rumus di atas menggunakan fungsi bawaan dari Python yaitu math.hypot, sehingga yang digunakan untuk menghitung jarak antara dua kota adalah sebagai berikut.

def distance(city1, city2):
    x1, y1 = cities[city1]
    x2, y2 = cities[city2]
    return math.hypot(x2 - x1, y2 - y1)

Adapun penjelasan dari syntax di atas yaitu kita punya data kota dengan koordinatnya (dalam cities). Selanjutnya Fungsi distance() akan mengambil dua kota, lalu ambil posisi (X dan Y) masing-masing. Selain itu digunakan pula Fungsi math.hypot() untuk menghitung jarak lurus menggunakan rumus Euclidean di atas.

Menghitung Jarak Total Seluruh Rute

Selanjutnya menghitung total jarak yang harus ditempuh dalam satu rute menggunakan fungsi total_distance

def total_distance(route):
    dist = 0
    for i in range(len(route)):
        dist += distance(route[i], route[(i+1) % len(route)])
    return dist

Adapun penjelasan syntax Python tersebut yaitu
def total_distance(route):
dist = 0
Berarti awalnya jarak total (dist) diset ke 0.

for i in range(len(route)):
dist += distance(route[i], route[(i+1) % len(route)])
Maknanya kita lakukan perulangan dari kota pertama sampai kota terakhir. Setiap iterasi, kita hitung jarak dari kota ke-i ke kota selanjutnya (i+1). Selanjutnya penggunaan % len(route) digunakan agar kota terakhir terhubung kembali ke kota pertama, jadi rutenya membentuk lingkaran.
Misalnya kita mempunyai 4 kota, (i+1) % 4 akan menjadi 0 saat i=3, sehingga menghitung jarak dari kota terakhir ke kota pertama.

return dist
Setelah selesai menghitung semua jarak antar kota, kita kembalikan nilai total jaraknya.

Membuat Populasi Awal (Acak)

Tahapan berikutnya yaitu membuat populasi awal secara acak. Adapun syntax yang digunakan adalah sebagai berikut

def generate_population(size):
    population = []
    city_list = list(cities.keys())
    for _ in range(size):
        individual = city_list[:]
        random.shuffle(individual)
        population.append(individual)
    return population

Sebagai catatan, berdasarkan syntax di atas:
* generate_population(size) untuk membuat banyak rute acak.
* city_list[:] berisi daftar kota
* random.shuffle() bertujuan untuk mengacak urutan kotanya.

Seleksi (Memilih yang Terbaik)

Setelah membuat populasi awal secara acak, selanjutnya kita dapat melakukan seleksi, yakni memilih rute terbaik. Syntax Python yang digunakan yaitu

def selection(population):
    sorted_pop = sorted(population, key=total_distance)
    return sorted_pop[:2]

Dalam hal ini kita menggunakan function selection untuk memilih 2 rute terbaik. Dengan terlebih dahulu diurutkan berdasarkan total jaraknya. Adapun rute terbaik yaitu rute dengan jarak terpendek sehingga akan lebih dipilih oleh Salesman.

Crossover (Perkawinan atau Genetik Silang)

Crossover adalah proses untuk membuat anak (solusi baru) dari dua orangtua (solusi yang ada). Tujuannya adalah menggabungkan sifat baik dari dua solusi untuk menghasilkan solusi baru yang lebih baik.

def crossover(parent1, parent2):
    size = len(parent1)
    start, end = sorted(random.sample(range(size), 2))
    child = [None] * size
    
    child[start:end+1] = parent1[start:end+1]
    
    fill_pos = 0
    for city in parent2:
        if city not in child:
            while child[fill_pos] is not None:
                fill_pos += 1
            child[fill_pos] = city
    return child

Adapun penjelasan dari syntax di atas yaitu:
def crossover(parent1, parent2):
size = len(parent1)
Digunakan untuk menghitung panjang rute berdasarkan jumlah kota

start, end = sorted(random.sample(range(size), 2))
Dalam hal ini memilih dua indeks secara acak dan urutkan, yang nantinya akan jadi batas awal dan akhir potongan dari parent1

child = [None] * size
Berarti kita membuat list kosong untuk anak (solusi baru)

child[start:end+1] = parent1[start:end+1]
Salin sebagian dari parent1 ke anak

fill_pos = 0
for city in parent2:
    if city not in child:
        while child[fill_pos] is not None:
            fill_pos += 1
        child[fill_pos] = city
Artinya untuk setiap kota di parent2, jika kota itu belum ada di anak, maka cari posisi kosong di anak (None), lalu isi dengan kota tersebut.

return child
Kembalikan anak yang sudah lengkap

Sehingga dapat dikatakan melalui fungsi crossover ini, kita membuat anak baru dengan cara:
– Mengambil sebagian gen dari parent1
– Mengisi sisanya dari parent2 tanpa duplikasi
– Hasilnya adalah gabungan rute unik dari dua orangtua

Mutasi

Mutasi yaitu mengacak sedikit isi rute, misalnya menukar posisi dua kota dalam rute perjalanan. Hal ini bertujuan agar
– Hasil tidak itu-itu saja (tidak monoton)
– Program bisa menjelajah solusi yang lebih luas dan tidak terjebak di solusi yang kurang bagus

Dalam hal ini, kita melakukan mutasi dengan function mutate. mutate adalah mengacak 2 kota di rute dengan peluang (dalam hal ini digunakan peluang 20%) agar populasi tidak monoton dan bisa eksplorasi solusi baru.

def mutate(route, mutation_rate=0.2):
    if random.random() < mutation_rate:
        i, j = random.sample(range(len(route)), 2)
        route[i], route[j] = route[j], route[i]
    return route

Adapun untuk penjelasan dari syntax di atas yaitu:
def mutate(route, mutation_rate=0.2):
Fungsi mutate menerima input berupa rute dan peluang mutasi (default 20%)

if random.random() < mutation_rate:
Ambil angka acak antara 0 dan 1. Kalau lebih kecil dari mutation_rate, maka lanjut mutasi.

i, j = random.sample(range(len(route)), 2)
Pilih dua posisi kota secara acak

route[i], route[j] = route[j], route[i]
Tukar posisi kedua kota itu

return route
Kembalikan rute (yang mungkin sudah diacak)

Visualisasi Rute Perjalanan

Berikutnya membuat visualisasi rute perjalanan menggunakan function plot_route, yakni dengan membuat gambar jalur dari rute. Dimana x dan y adalah daftar posisi titik-titik kota, lalu plt.plot() untuk menggambar garis, serta plt.text() menambahkan label kota. Tak lupa pula diberi judul mengenai informasi generasi dan total jarak yang ditempuh.

def plot_route(route, generation, distance_value):
    x = [cities[city][0] for city in route + [route[0]]]
    y = [cities[city][1] for city in route + [route[0]]]
    plt.figure(figsize=(8, 6))
    plt.plot(x, y, 'bo-', markersize=10)
    for idx, city in enumerate(route):
        plt.text(cities[city][0]+0.2, cities[city][1]+0.2, str(city), fontsize=12)
    plt.title(f"Generasi {generation} - Jarak: {distance_value:.2f}")
    plt.xlabel("X")
    plt.ylabel("Y")
    plt.grid(True)
    plt.show()

Fungsi Utama Genetic Algorithm

def genetic_algorithm(generations, population_size):
    population = generate_population(population_size)
    best_route = None
    best_distance = float('inf')
    
    for generation in range(1, generations+1):
        parent1, parent2 = selection(population)
        child1 = mutate(crossover(parent1, parent2))
        child2 = mutate(crossover(parent1, parent2))
        
        population = [parent1, parent2, child1, child2]
        
        population += generate_population(population_size - len(population))
        
        current_best = min(population, key=total_distance)
        current_distance = total_distance(current_best)
        
        if current_distance < best_distance:
            best_distance = current_distance
            best_route = current_best
        
        if generation % 5 == 0 or generation == generations:
            print(f"Generasi {generation}: rute = {current_best}, jarak = {current_distance:.2f}")
            plot_route(current_best, generation, current_distance)
    
    return best_route

Buat populasi awal.
Setiap generasi:
- Pilih 2 terbaik.
- Buat anak-anak baru lewat crossover dan mutasi.
- Tambahkan individu acak untuk keberagaman.
- Cari yang terbaik di generasi ini.
- Gambar rutenya tiap 5 generasi.
Setelah selesai, kembalikan rute terbaik.

Menjalankan Algoritma

Tahapan terakhir, kita akan menjalankan algoritma genetika (GA) yang meniru proses evolusi untuk mencari solusi terbaik.
Jalankan GA dengan 30 generasi dan 10 individu di tiap generasi. Setelah selesai, tampilkan rute terbaik (mencari rute terpendek yang mengunjungi semua titik/kota) serta total jaraknya.

best_route = genetic_algorithm(generations=30, population_size=10)
print(f"\nRute terbaik: {best_route}")
print(f"Total jarak: {total_distance(best_route):.2f}")

Singkatnya : Kita mulai dengan banyak rute acak → pilih yang bagus → kawinkan/mutasi → terus perbaiki → cari rute terpendek → visualisasikan!

Berdasarkan hasil grafik di atas, kita mendapatkan visualisasi rute terbaik yang ditemukan saat generasi ke-5, dengan total jarak 22.35, dimana pada grafik tersebut terdapat titik-titik yang mewakili kota, kemudian angka 0, 1, 3, 4, 2. adalah urutan kunjungan, serta garis biru menunjukkan jalur perjalanan.

Referensi

Eiben, A. E., & Smith, J. E. (2015). Introduction to Evolutionary Computing. Springer.

Mitchell, M. (1998). An Introduction to Genetic Algorithms. MIT Press.

Sekian penjelasan terkait Tutorial Algoritma Genetika dengan Python. Jika masih terdapat hal-hal yang dibingungkan bisa langsung saja ramaikan kolom komentar atau hubungi admin melalui tombol bantuan di kanan bawah. Stay tuned di website https://exsight.id/blog/ agar tidak ketinggalan artikel-artikel menarik lainnya.

Algoritma Genetika (Tutorial Python) – Part 2 Read More »