Alur Pelatihan Model

Dua chapter sebelumnya kita menyiapkan bahan-bahannya satu per satu: cara membagi data latih dan data uji, lalu cara membangun baseline sebagai lantai patokan. Pada chapter ini kita rangkai seluruh bahan itu menjadi satu alur kerja utuh yang dijalankan dari atas ke bawah tanpa terputus. Alurnya lima langkah: menyiapkan data, memisahkan dataset, melatih model, memprediksi, lalu mengukur performa. Kerangka ini adalah rutinitas baku setiap proyek machine learning — sekali kita paham peran tiap langkahnya, berganti model tinggal menukar satu baris kode di tengah, tanpa membongkar kerangkanya.

Lima Langkah Baku Alur Pelatihan #

Hampir semua pekerjaan machine learning, dari prediksi churn sampai peramalan harga, berakhir pada lima pekerjaan yang sama persis. Tiap langkah menjawab satu pertanyaan dan menghasilkan bahan untuk langkah berikutnya:

Urutan kelima langkah tidak bisa diacak. Model hanya boleh belajar dari data latih, sehingga pembagian dataset wajib lebih dulu; dan metrik hanya bermakna bila dihitung dari tebakan yang benar-benar keluar dari model. Kita jalankan alur lengkapnya pada data 20 member Toko Kopi Kita yang sudah akrab, kali ini dengan model sungguhan: LogisticRegression.

Alur Lengkap dalam Satu Skrip #

Skrip berikut memuat kelima langkah sekaligus, dari data mentah sampai satu angka akurasi. Perhatikan komentar di tiap blok — komentar itulah peta langkahnya:

import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split

# Langkah 1: siapkan data beserta fitur dan target
member = pd.DataFrame({
    "frekuensi_belanja": [2, 1, 7, 3, 6, 3, 8, 5, 2, 6, 4, 1, 7, 5, 8, 4, 6, 5, 7, 6],
    "lama_member_bulan": [3, 2, 24, 5, 20, 6, 30, 15, 4, 26, 12, 3, 22, 16, 28, 10, 18, 14, 19, 13],
    "churn": [1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
})
X = member[["frekuensi_belanja", "lama_member_bulan"]]
y = member["churn"]

# Langkah 2: pisahkan data latih dan data uji
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=42, stratify=y
)

# Langkah 3: latih model pada data latih
model = LogisticRegression()
model.fit(X_train, y_train)

# Langkah 4: minta model memprediksi data uji
prediksi = model.predict(X_test)

# Langkah 5: ukur performa prediksi dengan metrik
print("Jumlah data latih : %d member" % len(X_train))
print("Jumlah data uji   : %d member" % len(X_test))
print("Label asli        :", y_test.tolist())
print("Prediksi model    :", prediksi.tolist())
print("Akurasi data uji  : %.2f" % accuracy_score(y_test, prediksi))

Output yang Dihasilkan:

Jumlah data latih : 15 member
Jumlah data uji   : 5 member
Label asli        : [0, 1, 0, 0, 0]
Prediksi model    : [0, 1, 0, 0, 0]
Akurasi data uji  : 1.00

Mari kita telusuri peran tiap langkah pada skrip di atas:

1. Langkah 1 (siapkan data): member menyimpan 20 baris riwayat member. Seleksi X = member[[...]] mengambil dua kolom fitur sebagai tabel dua dimensi, dan y = member["churn"] mengambil kolom jawaban sebagai deret satu dimensi — bentuk yang dipatenkan konvensi scikit-learn pada chapter Fitur dan Target.
2. Langkah 2 (train_test_split): 15 member menjadi data latih dan 5 member menjadi data uji. stratify=y menjaga proporsi kelas, dan random_state=42 membuat pembagian yang sama lahir di setiap eksekusi — bahasan chapter Pemisahan Dataset.
3. Langkah 3 (model.fit(X_train, y_train)): LogisticRegression memindai 15 member latih dan menyimpan pola hubungan kedua fitur dengan kecenderungan berhenti. Model belum pernah melihat lima member uji sama sekali.
4. Langkah 4 (model.predict(X_test)): model menebar tebakan 0 atau 1 untuk kelima member uji tanpa diberi tahu jawaban aslinya; hasilnya disimpan di prediksi.
5. Langkah 5 (accuracy_score): metrik membandingkan tebakan dengan label asli baris demi baris — kelima tebakan tepat, akurasi 5/5 = 1.00.

Angka 1.00 perlu dibaca dengan kepala dingin. Model memang melampaui lantai baseline 0.80 yang dipatok DummyClassifier pada chapter sebelumnya, tetapi lima baris data uji adalah panggung yang terlalu kecil untuk angka sebesar itu: satu member berpindah kubu menggeser akurasi sejauh 0.20. Yang membawa kita maju bukan angkanya, melainkan kenyataan bahwa kelima langkah berjalan di tempatnya masing-masing — kerangka inilah yang nanti kita pakai berulang di data yang jauh lebih besar.

Menerapkan Model pada Data Baru #

Alur lima langkah berhenti di angka metrik, tetapi tujuan sesungguhnya model justru dimulai setelah itu: menebak member yang baru mendaftar, yang tidak punya label karena masa depannya belum terjadi. Kode berikut melatih ulang model yang sama, lalu menghadapkannya pada tiga member baru:

import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

member = pd.DataFrame({
    "frekuensi_belanja": [2, 1, 7, 3, 6, 3, 8, 5, 2, 6, 4, 1, 7, 5, 8, 4, 6, 5, 7, 6],
    "lama_member_bulan": [3, 2, 24, 5, 20, 6, 30, 15, 4, 26, 12, 3, 22, 16, 28, 10, 18, 14, 19, 13],
    "churn": [1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
})
X = member[["frekuensi_belanja", "lama_member_bulan"]]
y = member["churn"]
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=42, stratify=y
)

model = LogisticRegression()
model.fit(X_train, y_train)

member_baru = pd.DataFrame({
    "frekuensi_belanja": [1, 2, 9],
    "lama_member_bulan": [2, 6, 32],
}, index=["Budi", "Siti", "Dewi"])

prediksi = model.predict(member_baru)
peluang_churn = model.predict_proba(member_baru)[:, 1]

for nama, tebakan, peluang in zip(member_baru.index, prediksi, peluang_churn):
    status = "berhenti" if tebakan == 1 else "bertahan"
    print("%-4s -> tebakan: %-8s (peluang churn %.2f)" % (nama, status, peluang))

Output yang Dihasilkan:

Budi -> tebakan: berhenti (peluang churn 0.98)
Siti -> tebakan: bertahan (peluang churn 0.44)
Dewi -> tebakan: bertahan (peluang churn 0.00)

Kita bedah bagian-bagian pentingnya:

1. member_baru dibangun sebagai data frame dua kolom dengan nama dan urutan kolom yang sama seperti X saat pelatihan — bentuk masukan predict() wajib meniru bentuk fitur latih. Kolom indeks nama hanya label, tidak ikut dihitung.
2. predict() mengembalikan tebakan kelas final (0 atau 1) untuk tiap member baru.
3. predict_proba() mengembalikan dua kolom: peluang kelas 0 dan peluang kelas 1. Irisan [:, 1] mengambil kolom kedua, yaitu peluang churn.
4. Bacaan hasilnya: Budi yang jarang belanja dan baru dua bulan menjadi member mendapat peluang churn 0.98 — kandidat kuat untuk dihubungi tim promosi. Dewi yang belanja sembilan kali dan sudah 32 bulan menjadi member nyaris pasti bertahan. Siti berada di perbatasan: peluang 0.44 membuat model menjawab “bertahan”, tetapi nyaris merupakan lemparan koin — profil Siti memang berdiri di antara dua kelompok pada data latih.

Alur yang Sama untuk Semua Model scikit-learn #

Kekuatan sesungguhnya kerangka ini terletak pada keseragaman antarmuka scikit-learn: semua model — LinearRegression untuk regresi, RandomForestClassifier untuk klasifikasi, hingga KNeighborsClassifier — menerima fit(X, y), melayani predict(X), dan dinilai dengan metrik yang sama. Mengganti model berarti mengganti satu baris pembuatan objek; empat langkah lainnya bergerak tanpa diubah. Keseragaman inilah yang membuat kebiasaan menguji banyak kandidat model terasa murah dan teratur.

Rangkuman #

• Alur pelatihan baku terdiri atas lima langkah berurutan: siapkan data (X dan y), pisahkan dataset (train_test_split), latih model (fit), prediksi data uji (predict), dan ukur performa dengan metrik (accuracy_score).
• Urutan langkah tidak bisa diacak: model hanya boleh belajar dari data latih, dan metrik hanya bermakna bila dihitung dari tebakan sungguhan.
• LogisticRegression pada 20 member Toko Kopi Kita mencapai akurasi 1.00 di data uji — melampaui baseline 0.80, meski lima baris uji membuat angkanya hanya patokan yang kasar.
• Untuk data benar-benar baru, predict() memberi tebakan kelas dan predict_proba() memberi peluangnya; ambang bawaan 0.50 bisa digeser sesuai biaya kesalahan.
• Keseragaman antarmuka fit/predict membuat kelima langkah berlaku untuk semua model scikit-learn.

Satu pertanyaan besar belum terjawab: akurasi 1.00 pada data uji memang bagus, tetapi apakah model kita juga akan bertahan pada data yang belum pernah dilihatnya sedikit pun? Kemampuan itulah yang disebut generalisasi, dan mengukurnya dengan jujur menjadi pokok bahasan chapter Generalisasi Model .

Referensi #

1. scikit-learn — train_test_split
2. scikit-learn — Metrics and scoring: model evaluation