Decision tree adalah salah satu algoritma machine learning yang paling intuitif: modelnya menyerupai alur tanya jawab yang biasa kita lakukan. Di antara varian decision tree, C4.5 menonjol karena kemampuannya menangani atribut numerik, missing value, dan menghasilkan aturan yang mudah dipahami. Artikel ini akan membimbing Anda — dari konsep teori hingga implementasi praktis — untuk membuat sendiri tool C4.5 menggunakan Python 3.14 dan Visual Studio Code.

1. Mengapa C4.5 layak dipelajari?

Algoritma C4.5 cocok untuk pemula dan peneliti karena beberapa alasan:

• Mudah divisualisasikan sebagai pohon keputusan.
• Dapat menangani data kategori dan numerik.
• Menghasilkan aturan (rule) yang dapat dibaca manusia.
• Memiliki mekanisme untuk mengatasi missing value dan pruning (pada implementasi lanjutan).

2. Konsep dasar: entropy, information gain, dan gain ratio

2.1 Entropy

Entropy mengukur ketidakpastian (uncertainty) dalam sebuah himpunan data. Rumus dasar:

Entropy(S) = - Σ p(i) * log2(p(i))

Semakin homogen kelas dalam S → entropy menurun.

2.2 Information Gain (IG)

IG mengukur penurunan entropy akibat mempartisi data berdasarkan atribut tertentu:

IG(S, A) = Entropy(S) - Σ (|S_v|/|S|) * Entropy(S_v)

2.3 Gain Ratio (Ciri khas C4.5)

C4.5 menggunakan gain ratio untuk mengurangi bias terhadap atribut dengan banyak nilai. Rumusnya membagi IG dengan split information (entropi distribusi partisi).

3. Persiapan lingkungan: Python 3.14 & VS Code

Langkah singkat setup:

1. Install Python 3.14: python.org
2. Install Visual Studio Code: code.visualstudio.com
3. Pasang paket yang diperlukan:

pip install pandas numpy tabulate matplotlib

Opsional (untuk visualisasi):

pip install graphviz

4. Studi kasus singkat: dataset & tujuan

Kita akan memakai dataset sederhana data_siswa.csv yang berisi kolom: Nilai, Kehadiran, Tugas, Lulus. Tujuannya: membangun pohon C4.5 untuk memprediksi kolom Lulus.

5. Struktur proyek

Buat struktur folder seperti berikut:

project-c45/
├── data_siswa.csv
├── c45.py
├── tree.py
└── main.py
      

6. Implementasi C4.5 (kode contoh)

Di bawah ini contoh implementasi sederhana C4.5 (tanpa pruning, fokus pada Gain Ratio & splitting kategori). Simpan sebagai c45.py.

import numpy as np
import pandas as pd
from math import log2

class C45:
    def __init__(self, df, target):
        self.df = df
        self.target = target

    def entropy(self, data):
        values = data[self.target].value_counts(normalize=True)
        entropy = -sum(values * np.log2(values))
        return entropy

    def gain(self, data, attribute):
        total_entropy = self.entropy(data)
        values = data[attribute].unique()
        weighted_entropy = 0

        for val in values:
            sub = data[data[attribute] == val]
            weighted_entropy += (len(sub) / len(data)) * self.entropy(sub)

        return total_entropy - weighted_entropy

    def split_info(self, data, attribute):
        values = data[attribute].value_counts(normalize=True)
        return -sum(values * np.log2(values))

    def gain_ratio(self, data, attribute):
        gain = self.gain(data, attribute)
        split = self.split_info(data, attribute)
        return gain / split if split != 0 else 0

    def find_best_attribute(self, data):
        attributes = [col for col in data.columns if col != self.target]
        best_attr = None
        best_ratio = -1

        for attr in attributes:
            ratio = self.gain_ratio(data, attr)
            if ratio > best_ratio:
                best_ratio = ratio
                best_attr = attr

        return best_attr

    def build_tree(self, data):
        if len(data[self.target].unique()) == 1:
            return data[self.target].iloc[0]

        best_attribute = self.find_best_attribute(data)
        tree = {best_attribute: {}}

        for value in data[best_attribute].unique():
            sub = data[data[best_attribute] == value]

            if sub.empty:
                tree[best_attribute][value] = data[self.target].mode()[0]
            else:
                tree[best_attribute][value] = self.build_tree(sub)

        return tree

7. Script utama (main.py)

Simpan script berikut sebagai main.py dan jalankan dari VS Code terminal.

import pandas as pd
from c45 import C45

df = pd.read_csv("data_siswa.csv")
model = C45(df, "Lulus")
tree = model.build_tree(df)

from tabulate import tabulate
print("===== Pohon Keputusan C4.5 =====")
print(tree)

8. Menjalankan dan membaca output

Di terminal VS Code jalankan:

python main.py

Anda akan melihat struktur dictionary yang merepresentasikan pohon keputusan. Contoh keluaran sederhana:

{
 'Nilai': {
   'Tinggi': 'Ya',
   'Sedang': {
     'Kehadiran': {'Bagus': 'Ya', 'Kurang': 'Tidak'}
   },
   'Rendah': 'Tidak'
 }
}

      {
        'Nilai': {
          'Tinggi': 'Ya',
          'Rendah': 'Tidak',
          'Sedang': {
            'Kehadiran': {
              'Bagus': 'Ya',
              'Kurang': {
                'Tugas': {
                  'Lengkap': 'Ya',
                  'Tidak': 'Tidak'
                }
              }
            }
          }
        }
      }
      

                           [Nilai]
                       /      |        \
                  Tinggi    Sedang     Rendah
                    |          |          |
                   Ya   [Kehadiran]     Tidak
                          /     \
                     Bagus     Kurang
                       |          |
                      Ya      [Tugas]
                                 /   \
                           Lengkap   Tidak
                              |         |
                             Ya       Tidak
      

      Nilai
      ├── Tinggi → Ya
      ├── Rendah → Tidak
      └── Sedang
          └── Kehadiran
              ├── Bagus → Ya
              └── Kurang
                  └── Tugas
                      ├── Lengkap → Ya
                      └── Tidak → Tidak
      

      RULE 1:
      IF Nilai = Tinggi THEN Lulus = Ya

      RULE 2:
      IF Nilai = Rendah THEN Lulus = Tidak

      RULE 3:
      IF Nilai = Sedang AND Kehadiran = Bagus THEN Lulus = Ya

      RULE 4:
      IF Nilai = Sedang AND Kehadiran = Kurang AND Tugas = Lengkap THEN Lulus = Ya

      RULE 5:
      IF Nilai = Sedang AND Kehadiran = Kurang AND Tugas = Tidak THEN Lulus = Tidak
      

      ===== Pohon Keputusan C4.5 =====
      {
        'Nilai': {
          'Tinggi': 'Ya',
          'Rendah': 'Tidak',
          'Sedang': {
            'Kehadiran': {
              'Bagus': 'Ya',
              'Kurang': {
                'Tugas': {
                  'Lengkap': 'Ya',
                  'Tidak': 'Tidak'
                }
              }
            }
          }
        }
      }

      ===== Aturan (Rules) =====
      1. IF Nilai = Tinggi THEN Lulus = Ya
      2. IF Nilai = Rendah THEN Lulus = Tidak
      3. IF Nilai = Sedang AND Kehadiran = Bagus THEN Lulus = Ya
      4. IF Nilai = Sedang AND Kehadiran = Kurang AND Tugas = Lengkap THEN Lulus = Ya
      5. IF Nilai = Sedang AND Kehadiran = Kurang AND Tugas = Tidak THEN Lulus = Tidak
      

9. Mengonversi pohon menjadi aturan (rules)

Pohon yang terbentuk mudah diubah menjadi aturan if-then. Contoh:

IF Nilai = Tinggi THEN Lulus = Ya
IF Nilai = Rendah THEN Lulus = Tidak
IF Nilai = Sedang AND Kehadiran = Bagus THEN Lulus = Ya

Rule ini dapat langsung dipakai pada aplikasi web sederhana (Flask) atau script Python yang menjalankan prediksi cepat.

10. Visualisasi pohon (opsional)

Untuk visualisasi, Anda bisa menggunakan graphviz atau library lain. Instal Graphviz lalu buat fungsi traversal tree untuk membangun objek DOT.

11. Ekstensi & perbaikan (selanjutnya)

• Menambahkan dukungan atribut numerik dengan _binning_ atau threshold otomatis.
• Pruning (mengurangi overfitting) menggunakan metode post-pruning.
• Mengatasi missing value secara lebih robust.
• Optimisasi performa untuk dataset besar (vektorisasi numpy).
• Menambahkan cross-validation dan evaluasi akurasi dengan scikit-learn.

12. Contoh integrasi kecil: antarmuka CLI

nilai = input("Masukkan Nilai (Tinggi/Sedang/Rendah): ")
kehadiran = input("Masukkan Kehadiran (Bagus/Kurang): ")

if nilai == "Tinggi":
    print("Prediksi Lulus: Ya")
elif nilai == "Rendah":
    print("Prediksi Lulus: Tidak")
else:
    if kehadiran == "Bagus":
        print("Prediksi Lulus: Ya")
    else:
        print("Prediksi Lulus: Tidak")

13. Kelebihan & keterbatasan C4.5

Kelebihan: interpretabilitas tinggi, cocok untuk pendidikan & penelitian, menangani kategori & numerik (dengan transformasi), dan menghasilkan rule yang jelas. Kekurangan: rawan overfitting pada data kecil, pohon bisa tumbuh sangat besar, dan tidak selalu optimal untuk dataset berukuran besar tanpa optimisasi.

14. Rekomendasi pembelajaran lebih lanjut

Untuk memperdalam, pelajari topik:

• Pruning (pre & post pruning)
• Cross-validation & metrik evaluasi (accuracy, precision, recall, F1)
• Random Forest (ensemble dari decision trees)
• Optimisasi dan pemrosesan fitur (feature engineering)

15. Referensi & sumber

• Decision tree learning — Wikipedia
• C4.5 algorithm — Wikipedia
• scikit-learn Decision Trees
• Dokumentasi Python: python.org

16. Penutup

Membangun tool C4.5 sendiri adalah latihan yang sangat baik untuk memahami dasar-dasar pembelajaran mesin: probabilitas, pengukuran informasi, dan pengambilan keputusan berbasis data. Dengan Python 3.14 dan VS Code Anda memiliki lingkungan yang kuat untuk eksperimen. Setelah paham dasar, Anda bisa mengembangkan fitur lebih lanjut—visualisasi interaktif, API prediksi, atau integrasi ke aplikasi yang lebih besar.