Apa itu Klasifikasi Data dengan Metode Feature Selection?

Pernah nggak kalian merasa pusing ngerjain klasifikasi data yang jumlahnya jutaan tapi hasilnya malah overfitting atau lemot banget? Kayaknya masalahnya ada di fitur yang nggak relevan atau kebanyakan “sampah” di data kalian. Dalam catatan belajar jadi Data Analis ini, kita bakal ngebedah metode feature selection secara mendalam biar proyek data kalian makin efisien.

Masalah klasifikasi data sepertinya udah jadi salah satu topik yang paling sering dibahas di komunitas data mining dan machine learning. Secara teknis, klasifikasi adalah proses buat nentuin label kategori dari data berdasarkan fitur-fitur yang ada. Nah, sebelum kalian masuk ke tahap klasifikasi, ada fase yang namanya pemilihan fitur atau feature selection yang krusial banget buat keberhasilan model kalian.

Tujuan utama dari feature selection adalah buat milih subset kecil dari fitur-fitur asli yang punya daya pembeda paling tinggi (highly discriminant). Kenapa ini penting? Soalnya sering kali data yang dikumpulin bukan dari ahlinya, jadi banyak fitur yang nggak nyambung sama label kelasnya. Fitur yang nggak relevan ini justru ngebikin akurasi makin ancur karena fenomena yang namanya overfitting. Dengan milih fitur yang pas, kalian bisa nurunin kompleksitas komputasi, ngebangun model yang lebih general, dan pastinya ngehemat penyimpanan data.

Kami bakal ngejelasin tiga model besar dalam pemilihan fitur ini:

Filter Models:

Model ini paling independen karena mereka ngevaluasi fitur tanpa butuh algoritma klasifikasi apapun. Mereka cuma ngeliat karakteristik umum dari data latih kalian, kayak jarak atau korelasi. Beberapa metrik populernya adalah:

Gini Index:

Digunain buat ngukur seberapa nggak seimbang nilai fitur di berbagai kelas. Rumusnya adalah

G(N) = 1 – \sum_{i=1}^{k} p_i^2

di mana $p_i$ adalah fraksi kelas yang sesuai sama nilai fitur tersebut. Semakin kecil nilainya, semakin kuat fitur itu dalam ngebedain kelas data.

Entropy dan Information Gain:

Ini ngukur tingkat ketidakpastian. Rumus entropi adalah

E = -\sum_{i=1}^{k} p_i \cdot \log(p_i)

Informasi yang didapet dari suatu fitur (Information Gain) diitung pake selisih entropi sebelum dan sesudah fitur itu diamati:

IG(f_i, C) = H(f_i) – H(f_i|C)

Fisher’s Index:

Ini ngukur rasio sebaran antar kelas dibanding sebaran di dalem kelas. Rumusnya:

F = \frac{\sum_{j=1}^{k} p_j \cdot (\mu_j – \mu)^2}{\sum_{j=1}^{k} p_j \cdot \sigma_j^2}

, di mana $\mu_j$ itu rata-rata fitur di kelas $j$ , dan $\sigma_j$ adalah standar deviasinya.

Wrapper Models:

Berbeda sama filter, model ini justru nyelipin proses pemilihan fitur ke dalem algoritma klasifikasi. Mereka pake strategi kayak greedy search buat nyoba kombinasi fitur tertentu dan ngeliat akurasi prediksinya gimana. Emang sih hasilnya biasanya lebih akurat, tapi buat data yang gedenya sampe 1 juta baris, rasanya komputasinya bakal berat banget alias mahal.

Embedded Models:

Ini kayak jalan tengah yang cerdas.

Pemilihan fitur dilakuin barengan sama waktu pelatihan model (learning time).

Contoh paling populernya itu Lasso Regularization ( $L_1$ -norm).

Rumus penaltinya adalah $\text{penalty}(w) = \sum_{i=1}^{m} |w_i|$ .

Sifat keren dari Lasso ini adalah dia bisa ngebikin koefisien fitur yang nggak relevan jadi bener-bener nol, jadi fitur itu otomatis “terbuang” pas modelnya dilatih.

Buat kalian yang mau nyoba ngebangun sistem buat klasifikasi 1 juta nilai ujian mahasiswa di Python, gini caranya:

Memuat Data Skala Besar: Gunakan library pandas buat nge-load data 1 juta baris kalian. Kalau memorinya nggak kuat, kalian bisa pake teknik chunking atau pake dask. Pastiin fitur kayak nilai harian, absen, dan durasi belajar mahasiswa udah masuk semua.
Preprocessing dan Normalisasi: Bersihin data dari nilai yang kosong. Nilai ujian biasanya punya skala beda-beda, jadi gunain StandardScaler buat normalisasi supaya fiturnya setara.
Menerapkan Filter Method (Information Gain): Gunakan SelectKBest dari scikit-learn dengan parameter mutual_info_classif. Ini bakal ngitung rumus Information Gain yang tadi kita bahas buat milih, misalnya, 10 fitur terbaik dari ratusan fitur mahasiswa yang kalian punya. Ini cocok buat data 1 juta baris karena itungannya relatif cepet.
Menerapkan Embedded Method (Lasso): Kalian bisa pake model LogisticRegression(penalty='l1', solver='liblinear'). Secara teknis, model ini bakal ngejalanin optimasi dan ngebikin fitur-fitur yang nggak ngaruh ke nilai ujian mahasiswa punya bobot nol.
Evaluasi dengan Cross-Validation: Jangan cuma percaya sama satu hasil. Bagi data kalian jadi beberapa subset (misal 5-fold) buat mastiin kalau pemilihan fitur kalian bener-bener stabil dan nggak cuma kebetulan doang.

Contoh dalam source code python:

import numpy as np
import pandas as pd
from sklearn.feature_selection import SelectKBest, mutual_info_classif
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler

# ==========================================
# 1. SIMULASI DATASET SKALA BESAR
# ==========================================
print("Mengenerate 1 juta data mahasiswa...")
n_samples = 1000000
n_features = 10

# Simulasi 10 fitur (misal: Nilai Ujian, Absen, Durasi Belajar, dll)
np.random.seed(42)
X = np.random.rand(n_samples, n_features)
# Label: 1 (Lulus), 0 (Tidak Lulus)
y = np.random.randint(0, 2, n_samples)

# ==========================================
# 2. PREPROCESSING (SCALING)
# ==========================================
print("Melakukan scaling data...")
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# ==========================================
# 3. FILTER METHOD (Information Gain / Mutual Info)
# ==========================================
print("\n[Menjalankan Filter Method]")
# Catatan: mutual_info_classif pada 1 juta data asli bisa sangat memakan waktu.
# Untuk demo cepat, kita gunakan subsample 10.000 data khusus untuk kalkulasi skor IG.
subsample_idx = np.random.choice(n_samples, 10000, replace=False)

selector = SelectKBest(score_func=mutual_info_classif, k=5)
selector.fit(X_scaled[subsample_idx], y[subsample_idx])

# Transformasikan seluruh data (1 juta) ke 5 fitur terbaik
X_filter = selector.transform(X_scaled)
print("Indeks fitur terpilih (IG):", selector.get_support(indices=True))

# ==========================================
# 4. EMBEDDED METHOD (Lasso Regularization / L1)
# ==========================================
print("\n[Menjalankan Embedded Method]")
# Menggunakan C=0.1 untuk mendesak koefisien fitur tidak penting menjadi nol
lasso = LogisticRegression(penalty='l1', solver='liblinear', C=0.1, random_state=42)
lasso.fit(X_scaled, y)

# Mengambil indeks fitur yang koefisiennya tidak nol
important_features = np.where(lasso.coef_[0] != 0)[0]
print("Indeks fitur penting menurut Lasso:", important_features)

dimana dalam contoh diatas:

Skalabilitas Data Juta-an: Menggunakan library seperti scikit-learn dikombinasikan dengan numpy sangat efisien karena operasinya berbasis matriks teroptimasi (C-backend).
StandardScaler: Langkah krusial agar fitur yang memiliki skala angka besar tidak mendominasi perhitungan jarak atau penalti rumus regulerisasi Lasso.
Filter Method (Information Gain): Diimplementasikan melalui fungsi mutual_info_classif. Kode di atas dimodifikasi dengan teknik subsampling (10.000 data) saat menghitung skor. Langkah ini adalah trik nyata di industri agar komputasi 1 juta data tidak stuck atau memakan waktu berjam-jam, namun tetap representatif.
Embedded Method (Lasso): Menggunakan LogisticRegression dengan parameter penalty='l1'. Parameter C=0.1 bertindak sebagai pengontrol kekuatan regulerisasi. Semakin kecil nilai C, semakin agresif Lasso dalam memaksa koefisien fitur “sampah” menjadi bunder nol, sehingga otomatis mengeliminasi fitur tersebut saat model dilatih.

Memilih metode feature selection yang bener itu emang tantangan tersendiri, apalagi skalabilitas jadi isu utama pas datanya nyentuh angka jutaan. Kami melihat kalau kalian pake metode filter, prosesnya bakal jauh lebih sat-set dan gampang dibanding wrapper. Tapi kalau kalian butuh akurasi yang lebih nendang dan punya sumber daya komputasi yang oke, Embedded Models kayak Lasso sepertinya jadi pilihan yang paling bijak. Jangan lupa buat selalu ngecek korelasi antar fitur, karena fitur yang saling berhubungan erat (redundan) sebenernya nggak ngasih info baru dan cuma nambah beban model doang.

Sekian dulu ya pembahasan teknis dari kami. Memilih fitur itu seni sekaligus sains, jadi jangan bosen buat bereksperimen. Rekan-rekanita, terima kasih sudah membaca artikel ini sampai habis, yuk kita mulai simpulkan bareng-bareng kira-kira fitur mana nih yang paling ngebantu kalian buat dapet nilai ujian bagus!

Sumber: Agharwal, Charu C. 2015. Data Classification Algorithm and Methods. Penerbit: CRC Press.