Feature selection pada chapter sebelumnya membuang fitur dengan cara paling jujur: kolom yang tidak informatif dikeluarkan apa adanya. Reduksi dimensi menempuh jalan yang berbeda dan lebih radikal: daripada memilih kolom lama, ia membuat kolom baru — komponen — yang merupakan campuran terukur dari seluruh fitur asli, lalu menyimpan hanya beberapa komponen pertama. Teknik utamanya adalah PCA (principal component analysis) yang sudah kita sentuh di Section Unsupervised Learning sebagai alat melihat struktur data tanpa label. Di sini kita memandangnya dari sisi feature engineering: PCA sebagai alat kompresi fitur menjelang pemodelan — berapa komponen yang cukup, bagaimana membaca bobotnya, dan apa yang ditukar dengan harga kompresi itu.

Kapan Fitur Perlu Diringkas #

Masalahnya sederhana: banyak fitur yang mirip satu sama lain membawa informasi yang sama lebih dari sekali. Resep minuman menyimpan gram kopi dan takaran air terpisah, padahal keduanya membentuk satu gagasan — kepekatan. Kolom-kolom redundan semacam itu membuat model melihat dimensi lebih banyak daripada informasi yang sebenarnya ada; ruang fitur membengkak sementara datanya tidak bertambah, dan jarak antar titik kehilangan makna. Reduksi dimensi memadatkannya: informasi yang tersebar di banyak kolom ditarik ke beberapa arah utama.

Alur kerjanya selalu tiga langkah dan urutannya tidak boleh ditukar: standardisasi dulu (PCA sensitif terhadap satuan — kolom berskala besar akan memalsukan arah variansi), lalu PCA, lalu pembacaan berapa komponen yang disimpan.

Mengukur Berapa Informasi yang Tertangkap #

Kualitas kompresi PCA terbaca dari explained_variance_ratio_: porsi variansi data yang dijelaskan tiap komponen. Kita pakai data resep 60 gelas minuman dengan lima fitur: gram kopi, mililiter air, mililiter susu, mililiter gula, dan satu fitur turunan — konsentrasi kopi per 100 ml air:

python 
import numpy as np
import pandas as pd
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

rng = np.random.default_rng(42)
n = 60
kopi_murni = rng.integers(10, 100, n)          # gram kopi per gelas
air = 180 + rng.integers(-20, 20, n)           # ml air
susu = rng.integers(0, 120, n)                 # ml susu
gula = rng.integers(0, 30, n)                  # ml sirup gula

# fitur turunan dari dua kolom di atas
konsentrasi = kopi_murni / air * 100           # gram per 100 ml

X = pd.DataFrame({
    "kopi_murni": kopi_murni,
    "air": air,
    "susu": susu,
    "gula": gula,
    "konsentrasi": konsentrasi,
})

X_z = StandardScaler().fit_transform(X)
pca = PCA().fit(X_z)
rasio = pca.explained_variance_ratio_

print("Porsi variansi tiap komponen utama:")
for i, r in enumerate(rasio, start=1):
    print(f"  PC{i}: {r:.3f}  (kumulatif {rasio[:i].sum():.3f})")

Output yang Dihasilkan:

text 
Porsi variansi tiap komponen utama:
  PC1: 0.409  (kumulatif 0.409)
  PC2: 0.231  (kumulatif 0.640)
  PC3: 0.213  (kumulatif 0.853)
  PC4: 0.146  (kumulatif 1.000)
  PC5: 0.000  (kumulatif 1.000)

Mari kita telaah hasilnya:

  1. PC5 nyaris nol (0,000): bukti paling jelas dari redundansi. Karena konsentrasi dibangun dari kopi_murni dan air yang variasinya kecil, ia hampir seluruhnya bisa diperkirakan dari keduanya — tidak ada arah variansi kelima yang tersisa. PCA menemukan kelebihan ini tanpa diberi tahu.
  2. Empat komponen pertama menjumlah 85,3%: tiga komponen (64,0%) atau empat (85,3%) adalah kandidat kompresi; lima komponen penuh jelas tidak dibutuhkan karena yang kelima kosong.
  3. Tidak ada komponen tunggal yang mendominasi (PC1 hanya 40,9%) — berbeda dari data yang semua kolomnya mengukur satu hal sama; di sini resep memang bervariasi ke beberapa arah: kepekatan, susu, gula.

Membaca Bobot Komponen #

Kompresi tanpa membaca isi komponennya adalah kotak gelap. Matriks components_ menyimpan bobot (loading) tiap fitur asli pada tiap komponen — angka besar (positif atau negatif) berarti fitur itu ikut menentukan arah komponen:

python 
import numpy as np
import pandas as pd
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

rng = np.random.default_rng(42)
n = 60
kopi_murni = rng.integers(10, 100, n)
air = 180 + rng.integers(-20, 20, n)
susu = rng.integers(0, 120, n)
gula = rng.integers(0, 30, n)
konsentrasi = kopi_murni / air * 100

X = pd.DataFrame({
    "kopi_murni": kopi_murni, "air": air, "susu": susu,
    "gula": gula, "konsentrasi": konsentrasi,
})

X_z = StandardScaler().fit_transform(X)
pca2 = PCA(n_components=2).fit(X_z)
X_kompres = pca2.transform(X_z)

print("Bentuk sebelum:", X_z.shape, "-> sesudah:", X_kompres.shape)
print()
print("Bobot (loading) tiap fitur pada 2 komponen:")
bobot = pd.DataFrame(pca2.components_.T, index=X.columns,
                     columns=["PC1", "PC2"]).round(2)
print(bobot.to_string())

Output yang Dihasilkan:

text 
Bentuk sebelum: (60, 5) -> sesudah: (60, 2)

Bobot (loading) tiap fitur pada 2 komponen:
              PC1   PC2
kopi_murni   0.68  0.15
air         -0.20  0.27
susu         0.07 -0.57
gula        -0.12  0.76
konsentrasi  0.69  0.12

Mari kita telaah hasilnya:

  1. Bentuk mengecil dari 5 menjadi 2 kolom — setiap baris kini digambarkan dua angka saja; itulah kompresi yang dicari, dengan harga 64% variansi yang terbawa (dari tabel sebelumnya).
  2. PC1 adalah sumbu kepekatan: bobot besar pada kopi_murni (0,68) dan konsentrasi (0,69) dengan tanda sama, serta air dengan tanda berlawanan (-0,20) — air naik membuat minuman lebih encer. Komponen pertama merangkum gagasan “segelas pekat atau encer”.
  3. PC2 adalah sumbu campuran: didominasi gula (0,76) dan susu (-0,57) — dua pemanis/manis yang bergerak relatif berlawanan. Dua komponen ini bersama-sama membedakan gelas-gelas menurut dua gagasan utamanya.
  4. Membaca bobot adalah satu-satunya cara memberi nama komponen: PCA sendiri hanya menghasilkan PC1, PC2, dan seterusnya; nama “kepekatan” dan “campuran” datang dari kita yang membaca bobotnya.

Harga yang Dibayar #

Reduksi dimensi bukan kemenangan gratis. Tiga biayanya perlu dipegang sebelum dipakai. Pertama, interpretasi berubah lapis: koefisien model di atas komponen tak lagi bisa dibaca sebagai “efek gram kopi” — komponen adalah campuran. Kedua, pemetaan bergantung data: komponen yang dilatih pada dataset ini berlaku hanya untuk data dengan pola serupa; data baru dengan pola berbeda butuh PCA yang dilatih ulang — dan pelatihannya, seperti semua transformasi, hanya boleh menyentuh data latih. Ketiga, variansi hilang: menyimpan 2 dari 5 komponen berarti membuang 36% variansi; bila bagian yang terbuang kebetulan memuat sinyal langka (misalnya ciri khusus segelintir pelanggan), sinyal itu ikut terbuang. Karena itu PCA paling cocok untuk fitur yang memang saling berkorelasi erat — justru di sanalah informasinya berulang dan murah untuk dipadatkan.

Rangkuman #

  • Reduksi dimensi membuat kolom baru (komponen) sebagai campuran fitur lama dan menyimpan beberapa yang teratas; PCA adalah teknik utamanya.
  • Alur wajib: standardisasi dulu, PCA kemudian — satuan yang berbeda akan memalsukan arah variansi.
  • explained_variance_ratio_ memberi porsi informasi tiap komponen dan jumlah kumulatifnya sebagai dasar memilih jumlah komponen.
  • Matriks bobot components_ memberi komponen makna — “sumbu kepekatan”, “sumbu manis” — dan hanya pembacaan bobot yang bisa melakukannya.
  • Harganya: koefisien model kehilangan keterbacaan langsung, pemetaan terikat data latih, dan sebagian variansi terbuang; paling cocok untuk fitur saling berkorelasi derat.

Kita kini memegang seluruh peralatan feature engineering: transformasi, encoding, penskalaan, fitur turunan, seleksi, hingga kompresi. Satu ancaman terbesar belum kita tangani secara utuh — dan ancaman itu diam-diam merusak semuanya bila diabaikan: kebocoran data. Chapter penutup Section ini mendedah ragamnya dan menegakkan disiplin mencegahnya: Mencegah Data Leakage .

Referensi #

  1. scikit-learn — Preprocessing
  2. pandas — User Guide
  3. NumPy — Absolute Beginners