Dunia teknologi saat ini sedang gila-gilanya membicarakan artificial intelligence. Setiap hari kita dibombardir istilah keren seperti neural networks, deep learning, atau algoritma canggih yang kesannya bikin merinding. Banyak developer pemula langsung ciut duluan, merasa harus punya gelar PhD di bidang matematika lanjut sebelum bisa menyentuh baris kode pertama. Padahal, jika kita bedah hype yang ada, esensinya jauh lebih sederhana dari yang dipikirkan orang-orang. Dalam panduan ini, kita bakal membedah What a Machine Learning Model is and How to Make One secara pragmatis, langsung dari fondasi dasarnya tanpa pemanis pemasaran.

Pada dasarnya, machine learning adalah soal membuat komputer belajar mengenali pola dari kumpulan contoh data, lalu menggunakan pola tersebut untuk menebak data baru. Sama persis seperti saat manusia belajar mengenali kucing setelah melihat ratusan gambar kucing. Komputer tidak diberi aturan baku, melainkan dibiarkan menemukan polanya sendiri.

Membalik Logika: Pemrograman Tradisional vs Machine Learning

Bagi yang terbiasa menulis kode secara konvensional, perpindahan paradigma ke machine learning sering kali memicu brain fog. Dalam pemrograman tradisional, aliran logikanya sangat linier. Anda memasukkan data, menuliskan aturan mainnya secara manual lewat struktur if-else, lalu komputer mengeluarkan jawaban.

Machine learning membalik alur kerja tersebut. Anda memberikan komputer sekumpulan contoh data beserta jawaban yang benar. Algoritma kemudian memprosesnya untuk menghasilkan aturan main atau logika bawaan yang kita sebut sebagai model.

Pendekatan	Input Utama	Output Yang Dihasilkan
Pemrograman Tradisional	Data + Aturan (Rules)	Jawaban (Answer)
Machine Learning	Contoh Data + Jawaban Benar	Model (Learned Rules)

Ketika model tersebut sudah dilatih dan menangkap polanya, Anda tinggal menyuapkan data baru ke dalamnya. Model akan memproses data tersebut dan memberikan prediksi secara mandiri.

Anatomi Data: Feature dan Label

Sebelum masuk ke baris kode, ada dua istilah wajib yang harus dipahami dalam ekosistem machine learning.

Pertama adalah Feature. Feature adalah informasi atau petunjuk yang digunakan model untuk membuat prediksi. Jika kita ingin memprediksi apakah seorang siswa bakal lulus ujian, jumlah jam belajar adalah feature-nya.

Kedua adalah Label. Label adalah jawaban atau target akhir yang ingin kita prediksi. Dalam kasus siswa tadi, status Lulus atau Gagal adalah labelnya.

Jika kita menambah variabel lain seperti tingkat kehadiran di kelas atau nilai ujian terdahulu, variabel-variabel tersebut bergabung menjadi serangkaian feature tambahan. Makin banyak petunjuk yang relevan, makin besar peluang model memahami konteks secara utuh.

Jenis Machine Learning yang kita bahas di sini adalah Supervised Learning. Artinya, kita melatih model menggunakan data yang sudah memiliki jawaban benar secara eksplisit. Model melihat input sekaligus output yang tepat selama proses latihan.

Menyiapkan Environment dan Dataset

Untuk membangun model pertama, pastikan Python sudah terpasang di sistem Anda. Buka terminal atau command prompt, buat folder proyek baru, lalu pasang pustaka scikit-learn. Pustaka ini menyediakan berbagai peralatan machine learning siap pakai sehingga kita tidak perlu menulis rumus matematika rumit dari nol.

bash
pip install scikit-learn

Buka teks editor favorit Anda seperti VS Code, lalu buat berkas baru bernama main.py.

Pustaka scikit-learn membutuhkan struktur data masukan (features) dalam bentuk dua dimensi (2D array/list), sedangkan jawaban (labels) dalam bentuk satu dimensi. Alasan di baliknya sederhana: sebuah dataset machine learning umumnya memiliki banyak baris (sampel) dan banyak kolom (feature).

Mari buat dataset buatan yang merepresentasikan jam belajar siswa beserta hasil ujiannya (0 untuk Gagal, 1 untuk Lulus).

python
# Format 2D untuk Features (X): Setiap elemen adalah list yang berisi jam belajar
X = [[1], [2], [3], [4], [5], [6], [7], [8]]

# Format 1D untuk Labels (y): Hasil ujian (0 = Fail, 1 = Pass)
y = [0, 0, 0, 1, 1, 1, 1, 1]

Langkah Demi Langkah Membangun Model Prediksi

Proses pembangunan model mengikuti workflow standar industri: memisahkan data, inisialisasi algoritma, melatih model, dan mengevaluasi kinerjanya.

1. Memisah Data Latih dan Data Uji

Menguji model menggunakan data yang sama persis saat pelatihan adalah kesalahan fatal. Itu sama saja seperti memberikan kunci jawaban ujian kepada siswa sebelum tes dimulai. Hasilnya tidak membuktikan apakah model benar-benar paham atau sekadar menghafal.

Kita gunakan fungsi train_test_split untuk membagi data secara acak.

python
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=42
)

Parameter test_size=0.25 menetapkan 25% data untuk pengujian dan 75% sisanya untuk pelatihan. Parameter random_state=42 memastikan hasil pembagian data tetap konsisten setiap kali program dijalankan.

2. Inisialisasi dan Pelatihan Model

Kita akan menggunakan algoritma Decision Tree Classifier. Decision tree bekerja dengan cara mengajukan serangkaian pertanyaan berbasis kondisi terhadap data untuk mengambil keputusan.

python
from sklearn.tree import DecisionTreeClassifier

# Membuat objek model
model = DecisionTreeClassifier()

# Melatih model menggunakan data latih
model.fit(X_train, y_train)

Baris model.fit(X_train, y_train) adalah inti dari seluruh proses machine learning. Di sinilah algoritma menjelajahi data latih, mencari pola, dan membangun logika internal untuk menghubungkan jumlah jam belajar dengan status kelulusan.

3. Menguji Prediksi dan Mengukur Akurasi

Setelah model selesai dilatih, saatnya menguji kemampuannya menebak data yang belum pernah dilihat sebelumnya.

python
from sklearn.metrics import accuracy_score

# Menguji model dengan data uji
predictions = model.predict(X_test)

# Menghitung persentase akurasi
accuracy = accuracy_score(y_test, predictions)
print(f"Akurasi Model: {accuracy * 100:.2f}%")

Untuk mencoba prediksi data baru secara spesifik, misalnya siswa yang belajar selama 5 jam:

python
student_data = [[5]]
new_prediction = model.predict(student_data)

if new_prediction[0] == 1:
    print("Prediksi Model: Lulus")
else:
    print("Prediksi Model: Gagal")

Kode Lengkap Proyek Pertama

Jika seluruh komponen di atas digabungkan ke dalam satu berkas main.py, bentuk kodenya adalah sebagai berikut:

python
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Data masukan dan jawaban
X = [[1], [2], [3], [4], [5], [6], [7], [8]]
y = [0, 0, 0, 1, 1, 1, 1, 1]

# Pemisahan dataset
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=42
)

# Inisialisasi dan pelatihan
model = DecisionTreeClassifier()
model.fit(X_train, y_train)

# Evaluasi
predictions = model.predict(X_test)
accuracy = accuracy_score(y_test, predictions)
print(f"Akurasi Model: {accuracy * 100:.2f}%")

# Uji coba data baru
hours_studied = [[5]]
prediction = model.predict(hours_studied)

if prediction[0] == 1:
    print("Prediksi Model: Lulus")
else:
    print("Prediksi Model: Gagal")

Realita Teknis: Apa yang Sebenarnya Terjadi di Dalam Model?

Model tidak memiliki intuisi atau kesadaran. Saat fungsi model.fit() dipanggil, algoritma Decision Tree menganalisis sebaran titik data lalu memotong titik keputusan terbaik. Dalam skenario jam belajar di atas, model mungkin menemukan aturan internal sederhana seperti: Apakah jam belajar lebih kecil atau sama dengan 3.5? Jika ya, hasilnya Gagal; jika tidak, hasilnya Lulus.

Ada dua istilah teknis penting yang mengatur perilaku ini:

• Parameter: Nilai internal yang dipelajari secara otomatis oleh model dari data selama proses pelatihan.
• Hyperparameter: Pengaturan awal yang kita tentukan manual sebelum pelatihan dimulai. Contohnya, kita bisa membatasi kedalaman pohon keputusan dengan opsi DecisionTreeClassifier(max_depth=3) agar model tidak tumbuh terlalu kompleks.

Bahaya Overfitting dan Underfitting

Tanpa kontrol yang tepat, model bisa mengalami Overfitting. Ini terjadi ketika model terlalu "menghafal" detail dan noise dari data latih secara berlebihan. Kinerjanya terlihat sempurna saat latihan, namun hancur total saat diberikan data baru di dunia nyata.

Sebaliknya, Underfitting terjadi saat model terlalu sederhana untuk menangkap pola dasar data. Kinerjanya buruk baik pada data latih maupun data uji. Kunci utama engineering di machine learning adalah mencari keseimbangan di tengah-tengah kedua kondisi ekstrem ini.

Mengapa Akurasi Tinggi Bisa Menyesatkan?

Akurasi 99% terdengar hebat di atas kertas, tapi bisa jadi jebakan mematikan. Bayangkan kasus deteksi penyakit langka di mana 99 dari 100 orang sampel adalah orang sehat. Model malas yang hanya bisa menebak "Sehat" untuk semua orang akan langsung mendapatkan akurasi 99%. Namun, model tersebut gagal total mendeteksi 1 orang yang benar-benar sakit.

Itulah mengapa praktisi kerap mengandalkan metrik evaluasi lain seperti precision, recall, F1 score, atau mean squared error tergantung pada sifat masalah yang ingin diselesaikan.

Mengembangkan Model ke Skala yang Lebih Luas

Dataset kecil dengan satu feature di atas sangat cocok untuk membangun mental model dasar. Namun, aplikasi dunia nyata bekerja dengan dataset yang jauh lebih masif dan beragam.

Menggunakan Banyak Feature Sekaligus

Kita bisa meningkatkan kompleksitas data dengan menambahkan feature baru. Misalnya, menggabungkan jam belajar dan persentase kehadiran di kelas.

python
# Format: [Jam Belajar, Persentase Kehadiran]
X_multi = [
    [1, 50],
    [2, 60],
    [3, 70],
    [4, 80],
    [5, 90],
    [6, 95]
]
y_multi = [0, 0, 0, 1, 1, 1]

model_multi = DecisionTreeClassifier()
model_multi.fit(X_multi, y_multi)

# Prediksi siswa baru: Belajar 5 jam, kehadiran 90%
print(model_multi.predict([[5, 90]]))

Masalah Klasifikasi vs Regresi

Model yang kita buat di atas menyelesaikan masalah Klasifikasi (menebak kategori: Lulus atau Gagal). Jika masalahnya berubah menjadi menebak angka kontinu (seperti memprediksi nilai ujian akhir berupa angka 0 sampai 100, atau harga rumah), kita menggunakan Regresi.

Alur kerjanya hampir identik. Pustaka scikit-learn menyediakan kelas seperti LinearRegression yang cara pemanggilannya sama persis: .fit() untuk melatih dan .predict() untuk menebak.

python
from sklearn.linear_model import LinearRegression

reg_model = LinearRegression()
reg_model.fit(X_train, y_train)
reg_prediction = reg_model.predict([[5]])

Keseragaman API ini adalah alasan mengapa scikit-learn menjadi standar industri untuk prototyping cepat.

Langkah Lanjutan untuk Praktisi

Setelah menguasai alur kerja dasar ini, fondasi Anda sudah cukup kuat untuk melangkah ke tahap berikutnya dalam ekosistem machine learning:

1. Pelajari NumPy dan pandas: Dua pustaka Python ini adalah standar wajib untuk memuat, membersihkan, dan memanipulasi dataset berukuran besar dari berkas CSV atau database.
2. Eksplorasi Data Visualisasi: Gunakan pustaka seperti matplotlib atau seaborn untuk membuat grafik sebaran data sebelum model dilatih. Visualisasi membantu menemukan pola anomali lebih cepat.
3. Coba Algoritma Lain: Telusuri algoritma populer lain seperti Support Vector Machines (SVM) atau Random Forests untuk memahami kelebihan dan kekurangan masing-masing model.
4. Pahami Dasar Matematika: Ketika siap masuk ke tingkat lanjut (seperti deep learning dan neural networks), pemahaman turunan (derivatives) dan optimasi gradien (gradients) akan membuka pemahaman mendalam tentang cara algoritma menyesuaikan parameternya.

Machine learning pada dasarnya bukanlah sihir atau otak buatan yang hidup di dalam komputer. Ini adalah pemodelan matematis berbasis data yang dibungkus oleh antarmuka pemrograman yang bersih. Fokus utama seorang developer adalah memahami data, memilih fitur yang tepat, serta memastikan model yang dibuat mampu melakukan generalisasi dengan baik saat diuji dengan realita di lapangan.

Referensi

• https://www.freecodecamp.org/news/what-a-machine-learning-model-is-and-how-to-make-one/