Dasar Machine Learning

Deep learning bukan pulau terpisah — deep learning adalah cabang machine learning yang memakai neural network berlapis sebagai modelnya. Sebelum menyusun lapisan demi lapisan, kita perlu menguasai cara kerja machine learning secara umum: bagaimana data disiapkan, bagaimana model dilatih, dan bagaimana kualitasnya diukur secara jujur. Pada chapter ini kita jalankan siklus machine learning lengkap dengan scikit-learn, membedakan supervised dan unsupervised learning, lalu membahas overfitting — masalah yang akan terus menemani kita sepanjang course ini. Dataset yang dipakai adalah digits, kumpulan gambar digit tulisan tangan bawaan scikit-learn yang kecil dan cepat diproses di CPU.

Siklus Machine Learning #

Setiap proyek machine learning, dari regresi sederhana sampai model bahasa besar, mengikuti pola kerja yang sama:

Siklusnya berjalan searah jarum jam: data mentah dibersihkan dan diubah menjadi fitur, model dilatih meminimalkan loss, lalu hasilnya dievaluasi. Evaluasi yang memadai menutup siklus; evaluasi yang memadai buruk mengirim kita kembali ke tahap fitur dengan pemahaman baru. Iterasi beberapa putaran adalah hal normal, bukan tanda kegagalan.

Supervised vs Unsupervised #

Dua paradigma utama machine learning dibedakan oleh ketersediaan label pada data latih:

Klasifikasi digit termasuk supervised: setiap gambar sudah menyertai angka benar 0-9. Clustering pelanggan termasuk unsupervised: kita hanya punya data dan meminta algoritma menemukan kelompok alaminya sendiri.

Contoh Supervised: Klasifikasi Digit #

Dataset digits berisi 1797 gambar tulisan tangan berukuran 8×8 piksel grayscale, sehingga setiap gambar menjadi vektor 64 fitur. Berkas supervised_digits.py membagi data menjadi subset latih dan uji, melatih LogisticRegression, lalu mengukur akurasi di kedua subset:

"""Klasifikasi digit tulisan tangan dengan LogisticRegression."""

from sklearn.datasets import load_digits
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split

digits = load_digits()
X, y = digits.data, digits.target

X_latih, X_uji, y_latih, y_uji = train_test_split(
    X, y, test_size=0.25, random_state=42, stratify=y
)

print("Jumlah fitur :", X.shape[1])
print("Sampel latih :", X_latih.shape[0])
print("Sampel uji   :", X_uji.shape[0])

model = LogisticRegression(max_iter=5000)
model.fit(X_latih, y_latih)

akurasi_latih = accuracy_score(y_latih, model.predict(X_latih))
akurasi_uji = accuracy_score(y_uji, model.predict(X_uji))
print("Akurasi latih:", round(akurasi_latih, 4))
print("Akurasi uji  :", round(akurasi_uji, 4))

Output yang Dihasilkan:

Jumlah fitur : 64
Sampel latih : 1347
Sampel uji   : 450
Akurasi latih: 1.0
Akurasi uji  : 0.96

Mari kita telaah kode di atas baris per baris:

1. Baris 8-9 (load_digits): memuat dataset dan memisahkan matriks fitur X (1797×64) dari vektor label y (angka 0-9). Rincian dataset tersedia pada dokumentasi load_digits .
2. Baris 11-13 (train_test_split): memisahkan 25% data sebagai subset uji. Argumen random_state=42 membuat pembagian reproducible; stratify=y menjaga proporsi tiap digit tetap seimbang di kedua subset. Perilaku lengkapnya dijelaskan di dokumentasi train_test_split .
3. Baris 19-20 (LogisticRegression, fit): melatih model klasifikasi 10 kelas. max_iter=5000 memberi solver iterasi tambahan agar konvergen penuh pada data 64 fitur ini. Detailnya ada di dokumentasi LogisticRegression .
4. Baris 22-25 (accuracy_score): mengukur akurasi pada data latih dan data uji secara terpisah. Akurasi latih sempurna (1.0) sedangkan akurasi uji 0.96.

Overfitting dan Arti Train/Test Split #

Angka 1.0 pada akurasi latih terlihat menggembirakan, tetapi justru angka 0.96 yang jujur. Data uji adalah simulasi data yang belum pernah dilihat model, jadi hanya angka tersebut yang menggambarkan kemampuan sesungguhnya. Selisih 4 poin persentase antara keduanya disebut generalization gap: model sedikit terlalu menyesuaikan diri dengan kekhasan data latih, padahal kita menginginkan pola umum yang berlaku untuk data apa pun. Gejala ini bernama overfitting dan makin mudah terjadi saat kapasitas model besar — neural network dengan jutaan parameter adalah kandidat utamanya, sehingga bab-bab berikutnya akan membahas cara mengatasinya: regularisasi dan data yang lebih banyak.

Contoh Unsupervised: Clustering dengan KMeans #

Tanpa label, pembelajaran tetap mungkin. Berkas unsupervised_kmeans.py membuat data sintetis pelanggan (2 fitur: frekuensi belanja dan nilai belanja rata-rata), lalu meminta KMeans menemukan tiga kelompok:

"""Clustering pelanggan sintetis dengan KMeans (unsupervised)."""

import numpy as np
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs

X, label_benar, pusat_benar = make_blobs(
    n_samples=300, centers=3, cluster_std=1.0, random_state=42,
    return_centers=True,
)

model = KMeans(n_clusters=3, n_init=10, random_state=42)
label = model.fit_predict(X)

print("Shape data      :", X.shape)
print("Jumlah cluster  :", len(set(label)))
print("Inertia         :", round(model.inertia_, 2))
print("Pusat sebenarnya:")
print(np.round(pusat_benar, 2))
print("Pusat ditemukan:")
print(np.round(model.cluster_centers_, 2))

Output yang Dihasilkan:

Shape data      : (300, 2)
Jumlah cluster  : 3
Inertia         : 566.86
Pusat sebenarnya:
[[-2.51  9.01]
 [ 4.64  1.97]
 [-6.88 -6.88]]
Pusat ditemukan:
[[-2.63  9.04]
 [-6.88 -6.98]
 [ 4.75  2.01]]

Mari kita telaah kode di atas baris per baris:

1. Baris 7-10 (make_blobs): membuat 300 titik data dua fitur di sekitar tiga pusat buatan. Argumen return_centers=True mengembalikan pusat aslinya agar bisa dibandingkan dengan hasil clustering.
2. Baris 12-13 (KMeans, fit_predict): algoritma mengelompokkan data menjadi k=3 cluster tanpa melihat label; n_init=10 berarti proses diulang 10 kali dari posisi awal berbeda dan hasil terbaik yang disimpan.
3. Baris 17 (inertia_): jumlah kuadrat jarak tiap titik ke pusat clusternya — semakin kecil semakin rapat kelompoknya. Nilai ini adalah metrik internal clustering.
4. Baris 19 dan 21 (pusat): pusat yang ditemukan [-2.63, 9.04], [-6.88, -6.98], [4.75, 2.01] berdekatan dengan pusat sebenarnya, hanya bergeser sedikit karena 300 sampel hanya perkiraan statistik dari distribusi aslinya. Perhatikan juga urutannya berbeda — penomoran cluster memang sewenang-wenang, yang bermakna adalah posisinya.

Contoh ini sengaja memakai data dua dimensi agar hasilnya bisa dibandingkan mata. Pada data nyata berdimensi ratusan, clustering tetap bekerja dengan cara yang sama namun kualitasnya perlu metrik evaluasi tersendiri.

Siklus machine learning kini kita pegang: data disiapkan, model dilatih, evaluasi jujur dijalankan, dan overfitting sudah kita kenali dari angka konkretnya. Satu detail penting pada contoh klasifikasi digit tadi masih kita lewat diam-diam — nilai pikselnya berkisar 0 sampai 16 dan itu kebetulan bersahabat dengan model. Ketika fitur memiliki skala yang beragam, urutan ceritanya berubah drastis, dan itulah pembahasan chapter berikutnya: representasi data numerik.