Semua bekal teori sudah di tangan: istilah inti, mekanisme loss, dan peta paradigma. Saatnya merangkainya menjadi model machine learning pertama yang benar-benar bekerja — dari data mentah sampai angka akurasi — dengan kode yang pendeknya mengejutkan. Kita akan mengklasifikasikan spesies bunga iris memakai algoritme k-nearest neighbors, mengikuti alur lima langkah yang menjadi pola dasar hampir semua proyek machine learning. Setiap langkah akan kita bedaah sampai ke baris kodenya, karena alur inilah yang akan Anda ulangi berkali-kali di sepanjang Course.

Peta Lima Langkah #

Sebelum menulis kode, mari kita pegang dulu gambar besarnya. Setiap proyek supervised learning klasifikasi mengikuti bentuk yang sama:

LangkahPanggilan kunciTujuan
1. Muat dataload_iris()Menyiapkan matriks fitur X dan vektor label y
2. Bagi datatrain_test_split(X, y, ...)Menyisihkan sebagian data sebagai data uji yang tak dilihat model
3. Latih modelKNeighborsClassifier(n_neighbors=3).fit(...)Model mempelajari pola dari data latih
4. Prediksimodel.predict(X_uji)Model menebak label data yang belum pernah dilihatnya
5. Evaluasiaccuracy_score(y_uji, y_pred)Membandingkan tebakan dengan jawaban sebenarnya

Urutannya bernilai: data uji disisihkan sebelum model dibuat (langkah 2 mendahului langkah 3), sehingga model tidak sempat “mengintip” soal ujian. Evaluasi pun baru bermakna setelah prediksi dibuat, bukan sebelumnya.

Kode Lengkap: Lima Langkah dalam Satu File #

File model-pertama.py berikut mengimplementasikan kelima langkah di atas dengan mencetak bentuk data, jumlah sampel, prediksi, dan akurasi di tiap persimpangan, sehingga kita bisa mengawasi apa yang terjadi di dalamnya.

python 
# Model machine learning pertama: klasifikasi spesies bunga iris.
# Alur lengkap lima langkah: muat data -> split -> latih -> prediksi -> evaluasi.

from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier

# Langkah 1: muat dataset iris (150 sampel, 4 fitur, 3 kelas).
iris = load_iris()
X = iris.data
y = iris.target
print(f"1) Muat data  : X berbentuk {X.shape}, y berbentuk {y.shape}")

# Langkah 2: pisahkan 25% data sebagai data uji yang disimpan dulu.
X_latih, X_uji, y_latih, y_uji = train_test_split(
    X, y, test_size=0.25, random_state=42, stratify=y
)
print(f"2) Split data : {X_latih.shape[0]} sampel latih, {X_uji.shape[0]} sampel uji")

# Langkah 3: buat model dan latih dengan data latih saja.
model = KNeighborsClassifier(n_neighbors=3)
model.fit(X_latih, y_latih)
print("3) Latih model: KNeighborsClassifier(n_neighbors=3).fit(X_latih, y_latih)")

# Langkah 4: minta model memprediksi data uji yang belum pernah dilihatnya.
y_pred = model.predict(X_uji)
print(f"4) Prediksi   : {y_pred.shape[0]} prediksi untuk {X_uji.shape[0]} sampel uji")

# Langkah 5: bandingkan prediksi dengan label sebenarnya.
akurasi = accuracy_score(y_uji, y_pred)
benar = int((y_uji == y_pred).sum())
print(f"5) Evaluasi   : akurasi {akurasi:.3f} ({benar} dari {len(y_uji)} benar)")

print()
print("Lima prediksi pertama vs label sebenarnya:")
for i in range(5):
    status = "benar" if y_pred[i] == y_uji[i] else "salah"
    nama_prediksi = iris.target_names[y_pred[i]]
    nama_aktual = iris.target_names[y_uji[i]]
    print(f"  sampel uji {i}: prediksi {nama_prediksi:<10} aktual {nama_aktual:<10} [{status}]")

Output yang Dihasilkan:

text 
1) Muat data  : X berbentuk (150, 4), y berbentuk (150,)
2) Split data : 112 sampel latih, 38 sampel uji
3) Latih model: KNeighborsClassifier(n_neighbors=3).fit(X_latih, y_latih)
4) Prediksi   : 38 prediksi untuk 38 sampel uji
5) Evaluasi   : akurasi 0.974 (37 dari 38 benar)

Lima prediksi pertama vs label sebenarnya:
  sampel uji 0: prediksi setosa     aktual setosa     [benar]
  sampel uji 1: prediksi versicolor aktual versicolor [benar]
  sampel uji 2: prediksi versicolor aktual versicolor [benar]
  sampel uji 3: prediksi versicolor aktual versicolor [benar]
  sampel uji 4: prediksi setosa     aktual setosa     [benar]

Bedah Langkah demi Langkah #

Langkah 1 — Memuat Dataset (baris 4–13) #

Baris 4–7 mengimpor empat perkakas: penyedia dataset, fungsi pembagi data, estimator KNN, dan fungsi metrik. Baris 10–12 memuat iris lalu memisahkan atributnya ke dalam dua variabel konvensi: X = iris.data berbentuk (150, 4) — 150 sampel, 4 fitur — dan y = iris.target berbentuk (150,) berisi kode kelas 0, 1, 2 untuk setosa, versicolor, virginica. Baris 13 mencetak kedua bentuk tersebut sebagai pemeriksaan awal bahwa data masuk dengan dimensi yang benar.

Langkah 2 — Membagi Data Latih dan Data Uji (baris 15–19) #

Baris 16–18 memanggil train_test_split dengan tiga argumen penting. test_size=0.25 menyisihkan 25% data (38 dari 150 sampel) sebagai data uji; sisanya, 112 sampel, menjadi data latih. stratify=y menjaga komposisi kelas tetap seimbang di kedua bagian — karena iris berisi 50 sampel per kelas, hasilnya data uji berisi 12–13 sampel dari tiap spesies, bukan potongan acak yang kebetulan didominasi satu spesies. random_state=42 mengendalikan pengacakan pembagiannya, dan baris 19 mencetak jumlah sampel tiap bagian.

Langkah 3 — Melatih Model (baris 21–24) #

Baris 22 membangun estimator KNeighborsClassifier dengan n_neighbors=3 — sebuah hyperparameter yang kita pilih sendiri, bukan dipelajari model. Algoritme KNN bekerja dengan logika sederhana: untuk satu bunga baru, cari tiga tetangga terdekatnya di ruang fitur (jarak diukur atas keempat pengukuran), lalu ambil mayoritas spesies ketiganya sebagai prediksi. Baris 23 menjalankan fit(X_latih, y_latih) — bagi KNN, “belajar” berarti menyimpan seluruh data latih dan labelnya sebagai basis pengetahuan; tidak ada parameter yang dihitung lebih dulu. Model ini disebut lazy learner karena pekerjaan beratnya ditunda sampai saat prediksi.

Langkah 4 — Memprediksi Data Uji (baris 26–28) #

Baris 27 memanggil predict(X_uji). Untuk tiap sampel uji, model mengukur jarak ke 112 sampel latih, memilih tiga terdekat, lalu memvoting spesiesnya. Hasilnya adalah y_pred — array 38 prediksi, dicetak jumlahnya di baris 28. Titik ini penting untuk dicamkan: X_uji tidak pernah disentuh saat fit; prediksi ini benar-benar tebakan untuk data yang belum pernah dilihat model.

Langkah 5 — Mengevaluasi (baris 30–41) #

Baris 31 menghitung akurasi: proporsi prediksi yang tepat, dengan rumus jumlah benar ÷ jumlah sampel uji. Baris 32 menghitung jumlah benar secara eksplisit lewat (y_uji == y_pred).sum(), dan baris 33 mencetak keduanya. Loop baris 36–41 lalu menampilkan lima pasangan prediksi-aktual pertama lengkap dengan nama spesiesnya, supaya angka-angka kode kelas 0/1/2 tetap bisa dibaca manusia.

Membaca Angka 0,974 #

Output menunjukkan akurasi 0,974 — 37 dari 38 sampel uji terklasifikasi benar. Satu kesalahan itu bukan kebetulan yang perlu disesali, melainkan wajar: spesies versicolor dan virginica memang tumpang tindih di ruang fitur iris, sehingga sebagian kecil individunya sulit dibedakan dari pengukuran kelopak dan mahkota saja. Model pertama tanpa penyetelan apa pun yang mencapai ~97% adalah titik awal yang sangat baik.

Perhatikan juga betapa sedikitnya “kode mesin” yang kita tulis: tidak ada perulangan jarak manual, tidak ada pengurutan tetangga, tidak ada rumus voting. scikit-learn menyembunyikan seluruh mekanik itu di balik fit dan predict, dan kontrak panggilan yang konsisten inilah — bukan kecanggihan satu algoritme — yang membuat pustaka ini begitu produktif. Bagaimana kontrak itu bekerja secara persis adalah bahasan Chapter Alur Kerja scikit-learn: fit dan predict.

Referensi Resmi #